diff --git a/.github/workflows/build-examples.yml b/.github/workflows/build-examples.yml new file mode 100644 index 0000000..9d05789 --- /dev/null +++ b/.github/workflows/build-examples.yml @@ -0,0 +1,20 @@ +name: Build Examples + +on: + push: + branches: ["**"] + pull_request: + branches: ["**"] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + - name: Make decode + run: make --directory=examples/decode + - name: Make encode + run: make --directory=examples/encode + - name: Run encode + run: examples/encode/encode diff --git a/README.md b/README.md index 5f8897b..4a132f8 100644 --- a/README.md +++ b/README.md @@ -1 +1,43 @@ -# fit-cpp-sdk \ No newline at end of file +# Garmin FIT C++ SDK + +## FIT SDK Documentation +The FIT SDK documentation is available at [https://developer.garmin.com/fit](https://developer.garmin.com/fit) +## FIT SDK Developer Forum +Share your knowledge, ask questions, and get the latest FIT SDK news in the [FIT SDK Developer Forum](https://forums.garmin.com/developer/). + +## Requirements +A C++ compiler is required to compile the FIT C++ SDK, such as the GNU g++/gcc, MSVC, or Apple Clang compilers. + +## Install +The FIT C++ SDK can be cloned from the [FIT C++ SDK repository on GitHub](https://github.com/garmin/fit-cpp-sdk). + +## Examples +Example implementations of the FIT SDK are provided and can be found in the examples/ folder. +* **Decode**: Demonstrates decoding a FIT file; and use of the Decode and Message Broadcaster classes and Message Listener event interfaces. + +* **Encode**: Demonstrates encoding a FIT file and programmatic generation of messages. Three sample FIT files are created. ExampleActivity.fit, ExampleSettings.fit, and ExampleMonitoringFile.fit + +To compile the examples, leverage the makefiles. Note that the makefiles use the GNU g++ compiler. +```bash +# Navigate to the example +cd /path/to/fit/sdk/cpp/examples/decode + +# Build the example project +make clean +make + +# Run the compiled example +./decode someFitFile.fit +``` + +```bash +# Navigate to the example +cd /path/to/fit/sdk/cpp/examples/encode + +# Build the example project +make clean +make + +# Run the compiled example +./encode +``` diff --git a/examples/decode/decode.cpp b/examples/decode/decode.cpp new file mode 100644 index 0000000..8045789 --- /dev/null +++ b/examples/decode/decode.cpp @@ -0,0 +1,315 @@ +//////////////////////////////////////////////////////////////////////////////// +// The following FIT Protocol software provided may be used with FIT protocol +// devices only and remains the copyrighted property of Garmin Canada Inc. +// The software is being provided on an "as-is" basis and as an accommodation, +// and therefore all warranties, representations, or guarantees of any kind +// (whether express, implied or statutory) including, without limitation, +// warranties of merchantability, non-infringement, or fitness for a particular +// purpose, are specifically disclaimed. +// +// Copyright 2008 Garmin Canada Inc. +//////////////////////////////////////////////////////////////////////////////// + +#include +#include + +#include "fit_decode.hpp" +#include "fit_mesg_broadcaster.hpp" +#include "fit_developer_field_description.hpp" + +class Listener + : public fit::FileIdMesgListener + , public fit::UserProfileMesgListener + , public fit::MonitoringMesgListener + , public fit::DeviceInfoMesgListener + , public fit::MesgListener + , public fit::DeveloperFieldDescriptionListener + , public fit::RecordMesgListener +{ +public: + + static void PrintValues(const fit::FieldBase& field) + { + for (FIT_UINT8 j=0; j< (FIT_UINT8)field.GetNumValues(); j++) + { + std::wcout << L" Val" << j << L": "; + switch (field.GetType()) + { + // Get float 64 values for numeric types to receive values that have + // their scale and offset properly applied. + case FIT_BASE_TYPE_ENUM: + case FIT_BASE_TYPE_BYTE: + case FIT_BASE_TYPE_SINT8: + case FIT_BASE_TYPE_UINT8: + case FIT_BASE_TYPE_SINT16: + case FIT_BASE_TYPE_UINT16: + case FIT_BASE_TYPE_SINT32: + case FIT_BASE_TYPE_UINT32: + case FIT_BASE_TYPE_SINT64: + case FIT_BASE_TYPE_UINT64: + case FIT_BASE_TYPE_UINT8Z: + case FIT_BASE_TYPE_UINT16Z: + case FIT_BASE_TYPE_UINT32Z: + case FIT_BASE_TYPE_UINT64Z: + case FIT_BASE_TYPE_FLOAT32: + case FIT_BASE_TYPE_FLOAT64: + std::wcout << field.GetFLOAT64Value(j); + break; + case FIT_BASE_TYPE_STRING: + std::wcout << field.GetSTRINGValue(j); + break; + default: + break; + } + std::wcout << L" " << field.GetUnits().c_str() << L"\n";; + } + } + + void OnMesg(fit::Mesg& mesg) override + { + printf("On Mesg:\n"); + std::wcout << L" New Mesg: " << mesg.GetName().c_str() << L". It has " << mesg.GetNumFields() << L" field(s) and " << mesg.GetNumDevFields() << " developer field(s).\n"; + + for (FIT_UINT16 i = 0; i < (FIT_UINT16)mesg.GetNumFields(); i++) + { + fit::Field* field = mesg.GetFieldByIndex(i); + std::wcout << L" Field" << i << " (" << field->GetName().c_str() << ") has " << field->GetNumValues() << L" value(s)\n"; + PrintValues(*field); + } + + for (auto devField : mesg.GetDeveloperFields()) + { + std::wcout << L" Developer Field(" << devField.GetName().c_str() << ") has " << devField.GetNumValues() << L" value(s)\n"; + PrintValues(devField); + } + } + + void OnMesg(fit::FileIdMesg& mesg) override + { + printf("File ID:\n"); + if (mesg.IsTypeValid()) + printf(" Type: %d\n", mesg.GetType()); + if (mesg.IsManufacturerValid()) + printf(" Manufacturer: %d\n", mesg.GetManufacturer()); + if (mesg.IsProductValid()) + printf(" Product: %d\n", mesg.GetProduct()); + if (mesg.IsSerialNumberValid()) + printf(" Serial Number: %u\n", mesg.GetSerialNumber()); + if (mesg.IsNumberValid()) + printf(" Number: %d\n", mesg.GetNumber()); + } + + void OnMesg(fit::UserProfileMesg& mesg) override + { + printf("User profile:\n"); + if (mesg.IsFriendlyNameValid()) + std::wcout << L" Friendly Name: " << mesg.GetFriendlyName().c_str() << L"\n"; + if (mesg.GetGender() == FIT_GENDER_MALE) + printf(" Gender: Male\n"); + if (mesg.GetGender() == FIT_GENDER_FEMALE) + printf(" Gender: Female\n"); + if (mesg.IsAgeValid()) + printf(" Age [years]: %d\n", mesg.GetAge()); + if ( mesg.IsWeightValid() ) + printf(" Weight [kg]: %0.2f\n", mesg.GetWeight()); + } + + void OnMesg(fit::DeviceInfoMesg& mesg) override + { + printf("Device info:\n"); + + if (mesg.IsTimestampValid()) + printf(" Timestamp: %d\n", mesg.GetTimestamp()); + + switch(mesg.GetBatteryStatus()) + { + case FIT_BATTERY_STATUS_CRITICAL: + printf(" Battery status: Critical\n"); + break; + case FIT_BATTERY_STATUS_GOOD: + printf(" Battery status: Good\n"); + break; + case FIT_BATTERY_STATUS_LOW: + printf(" Battery status: Low\n"); + break; + case FIT_BATTERY_STATUS_NEW: + printf(" Battery status: New\n"); + break; + case FIT_BATTERY_STATUS_OK: + printf(" Battery status: OK\n"); + break; + default: + printf(" Battery status: Invalid\n"); + break; + } + } + + void OnMesg(fit::MonitoringMesg& mesg) override + { + printf("Monitoring:\n"); + + if (mesg.IsTimestampValid()) + { + printf(" Timestamp: %d\n", mesg.GetTimestamp()); + } + + if(mesg.IsActivityTypeValid()) + { + printf(" Activity type: %d\n", mesg.GetActivityType()); + } + + switch(mesg.GetActivityType()) // The Cycling field is dynamic + { + case FIT_ACTIVITY_TYPE_WALKING: + case FIT_ACTIVITY_TYPE_RUNNING: // Intentional fallthrough + if(mesg.IsStepsValid()) + { + printf(" Steps: %d\n", mesg.GetSteps()); + } + break; + case FIT_ACTIVITY_TYPE_CYCLING: + case FIT_ACTIVITY_TYPE_SWIMMING: // Intentional fallthrough + if( mesg.IsStrokesValid() ) + { + printf( "Strokes: %f\n", mesg.GetStrokes()); + } + break; + default: + if(mesg.IsCyclesValid() ) + { + printf( "Cycles: %f\n", mesg.GetCycles()); + } + break; + } + } + + static void PrintOverrideValues( const fit::Mesg& mesg, FIT_UINT8 fieldNum ) + { + std::vector fields = mesg.GetOverrideFields( fieldNum ); + const fit::Profile::FIELD * profileField = fit::Profile::GetField( mesg.GetNum(), fieldNum ); + FIT_BOOL namePrinted = FIT_FALSE; + + for ( const fit::FieldBase* field : fields ) + { + if ( !namePrinted ) + { + printf( " %s:\n", profileField->name.c_str() ); + namePrinted = FIT_TRUE; + } + + if ( FIT_NULL != dynamic_cast( field ) ) + { + // Native Field + printf( " native: " ); + } + else + { + // Developer Field + printf( " override: " ); + } + + switch (field->GetType()) + { + // Get float 64 values for numeric types to receive values that have + // their scale and offset properly applied. + case FIT_BASE_TYPE_ENUM: + case FIT_BASE_TYPE_BYTE: + case FIT_BASE_TYPE_SINT8: + case FIT_BASE_TYPE_UINT8: + case FIT_BASE_TYPE_SINT16: + case FIT_BASE_TYPE_UINT16: + case FIT_BASE_TYPE_SINT32: + case FIT_BASE_TYPE_UINT32: + case FIT_BASE_TYPE_SINT64: + case FIT_BASE_TYPE_UINT64: + case FIT_BASE_TYPE_UINT8Z: + case FIT_BASE_TYPE_UINT16Z: + case FIT_BASE_TYPE_UINT32Z: + case FIT_BASE_TYPE_UINT64Z: + case FIT_BASE_TYPE_FLOAT32: + case FIT_BASE_TYPE_FLOAT64: + printf("%f\n", field->GetFLOAT64Value()); + break; + case FIT_BASE_TYPE_STRING: + printf("%ls\n", field->GetSTRINGValue().c_str()); + break; + default: + break; + } + } + } + + void OnMesg( fit::RecordMesg& record ) override + { + printf( "Record:\n" ); + PrintOverrideValues( record, fit::RecordMesg::FieldDefNum::HeartRate); + PrintOverrideValues( record, fit::RecordMesg::FieldDefNum::Cadence ); + PrintOverrideValues( record, fit::RecordMesg::FieldDefNum::Distance ); + PrintOverrideValues( record, fit::RecordMesg::FieldDefNum::Speed ); + } + + void OnDeveloperFieldDescription( const fit::DeveloperFieldDescription& desc ) override + { + printf( "New Developer Field Description\n" ); + printf( " App Version: %d\n", desc.GetApplicationVersion() ); + printf( " Field Number: %d\n", desc.GetFieldDefinitionNumber() ); + } +}; + +int main(int argc, char* argv[]) +{ + fit::Decode decode; + // decode.SkipHeader(); // Use on streams with no header and footer (stream contains FIT defn and data messages only) + // decode.IncompleteStream(); // This suppresses exceptions with unexpected eof (also incorrect crc) + fit::MesgBroadcaster mesgBroadcaster; + Listener listener; + std::fstream file; + + printf("FIT Decode Example Application\n"); + + if (argc != 2) + { + printf("Usage: decode.exe \n"); + return -1; + } + + file.open(argv[1], std::ios::in | std::ios::binary); + + if (!file.is_open()) + { + printf("Error opening file %s\n", argv[1]); + return -1; + } + + if (!decode.CheckIntegrity(file)) + { + printf("FIT file integrity failed.\nAttempting to decode...\n"); + } + + mesgBroadcaster.AddListener((fit::FileIdMesgListener &)listener); + mesgBroadcaster.AddListener((fit::UserProfileMesgListener &)listener); + mesgBroadcaster.AddListener((fit::MonitoringMesgListener &)listener); + mesgBroadcaster.AddListener((fit::DeviceInfoMesgListener &)listener); + mesgBroadcaster.AddListener((fit::RecordMesgListener&)listener); + mesgBroadcaster.AddListener((fit::MesgListener &)listener); + + try + { + decode.Read(&file, &mesgBroadcaster, &mesgBroadcaster, &listener); + } + catch (const fit::RuntimeException& e) + { + printf("Exception decoding file: %s\n", e.what()); + return -1; + } + catch (...) + { + printf("Exception decoding file"); + return -1; + } + + printf("Decoded FIT file %s.\n", argv[1]); + + return 0; +} + diff --git a/examples/decode/makefile b/examples/decode/makefile new file mode 100644 index 0000000..847bb6d --- /dev/null +++ b/examples/decode/makefile @@ -0,0 +1,68 @@ +CC=g++ +CFLAGS=-I"." -I"../../" + +decode: decode.o fit_developer_field.o fit_developer_field_definition.o fit_developer_field_description.o fit_field_base.o fit.o fit_accumulated_field.o fit_accumulator.o fit_buffered_mesg_broadcaster.o fit_buffered_record_mesg_broadcaster.o fit_crc.o fit_decode.o fit_field.o fit_field_definition.o fit_mesg.o fit_mesg_broadcaster.o fit_mesg_definition.o fit_mesg_with_event_broadcaster.o fit_profile.o fit_unicode.o + $(CC) $(CFLAGS) decode.o fit_developer_field.o fit_developer_field_definition.o fit_developer_field_description.o fit_field_base.o fit.o fit_accumulated_field.o fit_accumulator.o fit_buffered_mesg_broadcaster.o fit_buffered_record_mesg_broadcaster.o fit_crc.o fit_decode.o fit_field.o fit_field_definition.o fit_mesg.o fit_mesg_broadcaster.o fit_mesg_definition.o fit_mesg_with_event_broadcaster.o fit_profile.o fit_unicode.o -o decode + +decode.o: decode.cpp + $(CC) $(CFLAGS) -c decode.cpp -o decode.o + +fit_developer_field.o: ../../fit_developer_field.cpp + $(CC) $(CFLAGS) -c ../../fit_developer_field.cpp -o fit_developer_field.o + +fit_developer_field_definition.o: ../../fit_developer_field_definition.cpp + $(CC) $(CFLAGS) -c ../../fit_developer_field_definition.cpp -o fit_developer_field_definition.o + +fit_developer_field_description.o: ../../fit_developer_field_description.cpp + $(CC) $(CFLAGS) -c ../../fit_developer_field_description.cpp -o fit_developer_field_description.o + +fit_field_base.o: ../../fit_field_base.cpp + $(CC) $(CFLAGS) -c ../../fit_field_base.cpp -o fit_field_base.o + +fit.o: ../../fit.cpp + $(CC) $(CFLAGS) -c ../../fit.cpp -o fit.o + +fit_accumulated_field.o: ../../fit_accumulated_field.cpp + $(CC) $(CFLAGS) -c ../../fit_accumulated_field.cpp -o fit_accumulated_field.o + +fit_accumulator.o: ../../fit_accumulator.cpp + $(CC) $(CFLAGS) -c ../../fit_accumulator.cpp -o fit_accumulator.o + +fit_buffered_mesg_broadcaster.o: ../../fit_buffered_mesg_broadcaster.cpp + $(CC) $(CFLAGS) -c ../../fit_buffered_mesg_broadcaster.cpp -o fit_buffered_mesg_broadcaster.o + +fit_buffered_record_mesg_broadcaster.o: ../../fit_buffered_record_mesg_broadcaster.cpp + $(CC) $(CFLAGS) -c ../../fit_buffered_record_mesg_broadcaster.cpp -o fit_buffered_record_mesg_broadcaster.o + +fit_crc.o: ../../fit_crc.cpp + $(CC) $(CFLAGS) -c ../../fit_crc.cpp -o fit_crc.o + +fit_decode.o: ../../fit_decode.cpp + $(CC) $(CFLAGS) -c ../../fit_decode.cpp -o fit_decode.o + +fit_field.o: ../../fit_field.cpp + $(CC) $(CFLAGS) -c ../../fit_field.cpp -o fit_field.o + +fit_field_definition.o: ../../fit_field_definition.cpp + $(CC) $(CFLAGS) -c ../../fit_field_definition.cpp -o fit_field_definition.o + +fit_mesg.o: ../../fit_mesg.cpp + $(CC) $(CFLAGS) -c ../../fit_mesg.cpp -o fit_mesg.o + +fit_mesg_broadcaster.o: ../../fit_mesg_broadcaster.cpp + $(CC) $(CFLAGS) -c ../../fit_mesg_broadcaster.cpp -o fit_mesg_broadcaster.o + +fit_mesg_definition.o: ../../fit_mesg_definition.cpp + $(CC) $(CFLAGS) -c ../../fit_mesg_definition.cpp -o fit_mesg_definition.o + +fit_mesg_with_event_broadcaster.o: ../../fit_mesg_with_event_broadcaster.cpp + $(CC) $(CFLAGS) -c ../../fit_mesg_with_event_broadcaster.cpp -o fit_mesg_with_event_broadcaster.o + +fit_profile.o: ../../fit_profile.cpp + $(CC) $(CFLAGS) -c ../../fit_profile.cpp -o fit_profile.o + +fit_unicode.o: ../../fit_unicode.cpp + $(CC) $(CFLAGS) -c ../../fit_unicode.cpp -o fit_unicode.o + +clean: + rm -f decode *.o diff --git a/examples/encode/encode.cpp b/examples/encode/encode.cpp new file mode 100644 index 0000000..b9cffb8 --- /dev/null +++ b/examples/encode/encode.cpp @@ -0,0 +1,337 @@ +//////////////////////////////////////////////////////////////////////////////// +// The following FIT Protocol software provided may be used with FIT protocol +// devices only and remains the copyrighted property of Garmin Canada Inc. +// The software is being provided on an "as-is" basis and as an accommodation, +// and therefore all warranties, representations, or guarantees of any kind +// (whether express, implied or statutory) including, without limitation, +// warranties of merchantability, non-infringement, or fitness for a particular +// purpose, are specifically disclaimed. +// +// Copyright 2008-2016 Garmin Canada Inc. +//////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include + +#include "fit_encode.hpp" +#include "fit_mesg_broadcaster.hpp" +#include "fit_file_id_mesg.hpp" +#include "fit_date_time.hpp" + +// 2 * PI (3.14159265) +#define TWOPI 6.2831853 + +// Number of semicircles per meter at the equator +#define SC_PER_M 107.173 + +int EncodeActivityFile() +{ + try + { + // Open the file + std::fstream file; + file.open("ExampleActivity.fit", std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc); + + if (!file.is_open()) + { + printf("Error opening file ExampleActivity.fit\n"); + return -1; + } + + // Create a FIT Encode object + fit::Encode encode(fit::ProtocolVersion::V20); + + // Write the FIT header to the output stream + encode.Open(file); + + // The starting timestamp for the activity + fit::DateTime startTime(std::time(0)); + + // Every FIT file MUST contain a File ID message + fit::FileIdMesg fileIdMesg; + fileIdMesg.SetType(FIT_FILE_ACTIVITY); + fileIdMesg.SetManufacturer(FIT_MANUFACTURER_DEVELOPMENT); + fileIdMesg.SetProduct(1); + fileIdMesg.SetTimeCreated(startTime.GetTimeStamp()); + // You should create a serial number unique to your platform + srand((unsigned int)time(NULL)); + fileIdMesg.SetSerialNumber(rand() % 10000 + 1); + encode.Write(fileIdMesg); + + // Create the Developer Id message for the developer data fields. + fit::DeveloperDataIdMesg developerIdMesg; + // It is a BEST PRACTICE to use the same Guid for all FIT files created by your platform + // 00010203-0405-0607-0809-0A0B0C0D0E0F + FIT_UINT8 appId[] = { 0x03,0x02,0x01,0x00,0x05,0x04,0x07,0x06,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }; + for (FIT_UINT8 i = 0; i < 16; i++) + { + developerIdMesg.SetApplicationId(i, appId[i]); + } + developerIdMesg.SetDeveloperDataIndex(0); + developerIdMesg.SetApplicationVersion(110); + encode.Write(developerIdMesg); + + // Create the Developer Data Field Descriptions + fit::FieldDescriptionMesg doughnutsFieldDescMesg; + doughnutsFieldDescMesg.SetDeveloperDataIndex(0); + doughnutsFieldDescMesg.SetFieldDefinitionNumber(0); + doughnutsFieldDescMesg.SetFitBaseTypeId(FIT_BASE_TYPE_FLOAT32); + doughnutsFieldDescMesg.SetFieldName(0, L"Doughnuts Earned"); + doughnutsFieldDescMesg.SetUnits(0, L"Doughnuts"); + doughnutsFieldDescMesg.SetNativeMesgNum(FIT_MESG_NUM_SESSION); + encode.Write(doughnutsFieldDescMesg); + + fit::FieldDescriptionMesg hrFieldDescMesg; + hrFieldDescMesg.SetDeveloperDataIndex(0); + hrFieldDescMesg.SetFieldDefinitionNumber(1); + hrFieldDescMesg.SetFitBaseTypeId(FIT_BASE_TYPE_UINT8); + hrFieldDescMesg.SetFieldName(0, L"Heart Rate"); + hrFieldDescMesg.SetUnits(0, L"bpm"); + hrFieldDescMesg.SetNativeFieldNum(fit::RecordMesg::FieldDefNum::HeartRate); + hrFieldDescMesg.SetNativeMesgNum(FIT_MESG_NUM_RECORD); + encode.Write(hrFieldDescMesg); + + // Timer Events are a BEST PRACTICE for FIT ACTIVITY files + fit::EventMesg eventMesgStart; + eventMesgStart.SetTimestamp(startTime.GetTimeStamp()); + eventMesgStart.SetEvent(FIT_EVENT_TIMER); + eventMesgStart.SetEventType(FIT_EVENT_TYPE_START); + encode.Write(eventMesgStart); + + // Every FIT ACTIVITY file MUST contain Record messages + fit::DateTime timestamp(startTime); + + // Create one hour (3600 seconds) of Record data + for (FIT_UINT16 i = 0; i < 3600; i++) + { + // Create a new Record message and set the timestamp + fit::RecordMesg recordMesg; + recordMesg.SetTimestamp(timestamp.GetTimeStamp()); + + // Fake Record Data of Various Signal Patterns + recordMesg.SetDistance(i); // Ramp + recordMesg.SetSpeed(1); // Flatline + recordMesg.SetHeartRate((FIT_UINT8)((sin(TWOPI * (0.01 * i + 10)) + 1.0) * 127.0)); // Sine + recordMesg.SetCadence((FIT_UINT8)(i % 255)); // Sawtooth + recordMesg.SetPower((FIT_UINT16)((i % 255) < 127 ? 150 : 250)); // Square + recordMesg.SetAltitude((float)std::abs(((float)(i % 255)) - 127.0f)); // Triangle + recordMesg.SetPositionLat(0); + recordMesg.SetPositionLong((FIT_SINT32)(i * SC_PER_M)); + + // Add a Developer Field to the Record Message + fit::DeveloperField developerHrField(hrFieldDescMesg, developerIdMesg); + developerHrField.AddValue((FIT_UINT8)((sin(TWOPI * (0.01 * i + 10)) + 1.0) * 127.0)); // Sine + recordMesg.AddDeveloperField(developerHrField); + + // Write the Rercord message to the output stream + encode.Write(recordMesg); + + // Increment the timestamp by one second + timestamp.add(fit::DateTime((FIT_DATE_TIME)1)); + } + + // Timer Events are a BEST PRACTICE for FIT ACTIVITY files + fit::EventMesg eventMesgStop; + eventMesgStop.SetTimestamp(timestamp.GetTimeStamp()); + eventMesgStop.SetEvent(FIT_EVENT_TIMER); + eventMesgStop.SetEventType(FIT_EVENT_TYPE_STOP); + encode.Write(eventMesgStop); + + // Every FIT ACTIVITY file MUST contain at least one Lap message + fit::LapMesg lapMesg; + lapMesg.SetTimestamp(timestamp.GetTimeStamp()); + lapMesg.SetStartTime(startTime.GetTimeStamp()); + lapMesg.SetTotalElapsedTime((FIT_FLOAT32)(timestamp.GetTimeStamp() - startTime.GetTimeStamp())); + lapMesg.SetTotalTimerTime((FIT_FLOAT32)(timestamp.GetTimeStamp() - startTime.GetTimeStamp())); + encode.Write(lapMesg); + + // Every FIT ACTIVITY file MUST contain at least one Session message + fit::SessionMesg sessionMesg; + sessionMesg.SetTimestamp(timestamp.GetTimeStamp()); + sessionMesg.SetStartTime(startTime.GetTimeStamp()); + sessionMesg.SetTotalElapsedTime((FIT_FLOAT32)(timestamp.GetTimeStamp() - startTime.GetTimeStamp())); + sessionMesg.SetTotalTimerTime((FIT_FLOAT32)(timestamp.GetTimeStamp() - startTime.GetTimeStamp())); + sessionMesg.SetSport(FIT_SPORT_STAND_UP_PADDLEBOARDING); + sessionMesg.SetSubSport(FIT_SUB_SPORT_GENERIC); + sessionMesg.SetFirstLapIndex(0); + sessionMesg.SetNumLaps(1); + + // Add a Developer Field to the Session message + fit::DeveloperField doughnutsEarnedDevField(doughnutsFieldDescMesg, developerIdMesg); + doughnutsEarnedDevField.AddValue(sessionMesg.GetTotalElapsedTime() / 1200.0f); + sessionMesg.AddDeveloperField(doughnutsEarnedDevField); + encode.Write(sessionMesg); + + // Every FIT ACTIVITY file MUST contain EXACTLY one Activity message + fit::ActivityMesg activityMesg; + activityMesg.SetTimestamp(timestamp.GetTimeStamp()); + activityMesg.SetNumSessions(1); + int timezoneOffset = -7 * 3600; + activityMesg.SetLocalTimestamp((FIT_LOCAL_DATE_TIME)((int)timestamp.GetTimeStamp() + timezoneOffset)); + encode.Write(activityMesg); + + // Update the data size in the header and calculate the CRC + if (!encode.Close()) + { + printf("Error closing encode.\n"); + return -1; + } + + // Close the file + file.close(); + + printf("Encoded FIT file ExampleActivity.fit.\n"); + return 0; + } + catch (...) + { + throw std::runtime_error("Exception encoding activity file"); + } +} +int EncodeSettingsFile() +{ + try + { + fit::Encode encode(fit::ProtocolVersion::V10); + std::fstream file; + + file.open("ExampleSettings.fit", std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc); + + if (!file.is_open()) + { + printf("Error opening file ExampleSettings.fit\n"); + return -1; + } + + fit::FileIdMesg fileIdMesg; // Every FIT file requires a File ID message + fileIdMesg.SetType(FIT_FILE_SETTINGS); + fileIdMesg.SetManufacturer(FIT_MANUFACTURER_DEVELOPMENT); + fileIdMesg.SetProduct(1); + fileIdMesg.SetSerialNumber(12345); + + fit::UserProfileMesg userProfileMesg; + userProfileMesg.SetGender(FIT_GENDER_FEMALE); + userProfileMesg.SetWeight((FIT_FLOAT32)63.1); + userProfileMesg.SetAge(99); + std::wstring wstring_name(L"TestUser"); + userProfileMesg.SetFriendlyName(wstring_name); + + encode.Open(file); + encode.Write(fileIdMesg); + encode.Write(userProfileMesg); + + if (!encode.Close()) + { + printf("Error closing encode.\n"); + return -1; + } + file.close(); + + printf("Encoded FIT file ExampleSettings.fit.\n"); + return 0; + } + catch (...) + { + throw std::runtime_error("Exception encoding settings file."); + } +} + +int EncodeMonitoringFile() +{ + try + { + fit::Encode encode(fit::ProtocolVersion::V10); + std::fstream file; + + time_t current_time_unix = time(0); + fit::DateTime initTime(current_time_unix); + + file.open("ExampleMonitoringFile.fit", std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc); + + if (!file.is_open()) + { + printf("Error opening file ExampleMonitoringFile.fit\n"); + return -1; + } + + encode.Open(file); + + fit::FileIdMesg fileIdMesg; // Every FIT file requires a File ID message + fileIdMesg.SetType(FIT_FILE_MONITORING_B); + fileIdMesg.SetManufacturer(FIT_MANUFACTURER_DEVELOPMENT); + fileIdMesg.SetProduct(1); + fileIdMesg.SetSerialNumber(12345); + + encode.Write(fileIdMesg); + + fit::DeviceInfoMesg deviceInfoMesg; + deviceInfoMesg.SetTimestamp(initTime.GetTimeStamp()); // Convert to FIT time and write timestamp. + deviceInfoMesg.SetBatteryStatus(FIT_BATTERY_STATUS_GOOD); + + encode.Write(deviceInfoMesg); + + fit::MonitoringMesg monitoringMesg; + + // By default, each time a new message is written the Local Message Type 0 will be redefined to match the new message. + // In this case,to avoid having a definition message each time there is a DeviceInfoMesg, we can manually set the Local Message Type of the MonitoringMessage to '1'. + // By doing this we avoid an additional 7 definition messages in our FIT file. + monitoringMesg.SetLocalNum(1); + + monitoringMesg.SetTimestamp(initTime.GetTimeStamp()); // Initialise Timestamp to now + monitoringMesg.SetCycles(0); // Initialise Cycles to 0 + for (int i = 0; i < 4; i++) // This loop represents 1/6 of a day + { + for (int j = 0; j < 4; j++) // Each one of these loops represent 1 hour + { + fit::DateTime walkingTime(current_time_unix); + monitoringMesg.SetTimestamp(walkingTime.GetTimeStamp()); + monitoringMesg.SetActivityType(FIT_ACTIVITY_TYPE_WALKING); // By setting this to WALKING, the Cycles field will be interpretted as Steps + monitoringMesg.SetCycles(monitoringMesg.GetCycles() + (rand() % 1000 + 1)); // Cycles are accumulated (i.e. must be increasing) + encode.Write(monitoringMesg); + current_time_unix += (time_t)(3600); //Add an hour to our contrieved timestamp + } + fit::DateTime statusTime(current_time_unix); + deviceInfoMesg.SetTimestamp(statusTime.GetTimeStamp()); + deviceInfoMesg.SetBatteryStatus(FIT_BATTERY_STATUS_GOOD); + encode.Write(deviceInfoMesg); + + } + + if (!encode.Close()) + { + printf("Error closing encode.\n"); + return -1; + } + file.close(); + + printf("Encoded FIT file ExampleMonitoringFile.fit.\n"); + return 0; + } + catch (...) + { + throw std::runtime_error("Exception encoding monitoring file."); + } +} + +int main() +{ + printf("FIT Encode Example Application\n"); + + int returnValue = 0; + + try + { + returnValue += EncodeSettingsFile(); + returnValue += EncodeMonitoringFile(); + returnValue += EncodeActivityFile(); + } + catch (const std::runtime_error &e) + { + printf("Exception occurred while encoding example files: %s", e.what()); + return -1; + } + + return returnValue; +} diff --git a/examples/encode/makefile b/examples/encode/makefile new file mode 100644 index 0000000..954eaba --- /dev/null +++ b/examples/encode/makefile @@ -0,0 +1,56 @@ +CC=g++ +CFLAGS=-I"." -I"../../" + +encode: encode.o fit_developer_field.o fit_developer_field_definition.o fit_field_base.o fit_protocol_validator.o fit.o fit_buffer_encode.o fit_crc.o fit_date_time.o fit_encode.o fit_field.o fit_field_definition.o fit_mesg.o fit_mesg_definition.o fit_profile.o fit_unicode.o + $(CC) $(CFLAGS) encode.o fit_developer_field.o fit_developer_field_definition.o fit_field_base.o fit_protocol_validator.o fit.o fit_buffer_encode.o fit_crc.o fit_date_time.o fit_encode.o fit_field.o fit_field_definition.o fit_mesg.o fit_mesg_definition.o fit_profile.o fit_unicode.o -o encode + +encode.o: encode.cpp + $(CC) $(CFLAGS) -c encode.cpp -o encode.o + +fit_developer_field.o: ../../fit_developer_field.cpp + $(CC) $(CFLAGS) -c ../../fit_developer_field.cpp -o fit_developer_field.o + +fit_developer_field_definition.o: ../../fit_developer_field_definition.cpp + $(CC) $(CFLAGS) -c ../../fit_developer_field_definition.cpp -o fit_developer_field_definition.o + +fit_field_base.o: ../../fit_field_base.cpp + $(CC) $(CFLAGS) -c ../../fit_field_base.cpp -o fit_field_base.o + +fit_protocol_validator.o: ../../fit_protocol_validator.cpp + $(CC) $(CFLAGS) -c ../../fit_protocol_validator.cpp -o fit_protocol_validator.o + +fit.o: ../../fit.cpp + $(CC) $(CFLAGS) -c ../../fit.cpp -o fit.o + +fit_buffer_encode.o: ../../fit_buffer_encode.cpp + $(CC) $(CFLAGS) -c ../../fit_buffer_encode.cpp -o fit_buffer_encode.o + +fit_crc.o: ../../fit_crc.cpp + $(CC) $(CFLAGS) -c ../../fit_crc.cpp -o fit_crc.o + +fit_date_time.o: ../../fit_date_time.cpp + $(CC) $(CFLAGS) -c ../../fit_date_time.cpp -o fit_date_time.o + +fit_encode.o: ../../fit_encode.cpp + $(CC) $(CFLAGS) -c ../../fit_encode.cpp -o fit_encode.o + +fit_field.o: ../../fit_field.cpp + $(CC) $(CFLAGS) -c ../../fit_field.cpp -o fit_field.o + +fit_field_definition.o: ../../fit_field_definition.cpp + $(CC) $(CFLAGS) -c ../../fit_field_definition.cpp -o fit_field_definition.o + +fit_mesg.o: ../../fit_mesg.cpp + $(CC) $(CFLAGS) -c ../../fit_mesg.cpp -o fit_mesg.o + +fit_mesg_definition.o: ../../fit_mesg_definition.cpp + $(CC) $(CFLAGS) -c ../../fit_mesg_definition.cpp -o fit_mesg_definition.o + +fit_profile.o: ../../fit_profile.cpp + $(CC) $(CFLAGS) -c ../../fit_profile.cpp -o fit_profile.o + +fit_unicode.o: ../../fit_unicode.cpp + $(CC) $(CFLAGS) -c ../../fit_unicode.cpp -o fit_unicode.o + +clean: + rm -f encode *.o *.fit diff --git a/fit.cpp b/fit.cpp new file mode 100644 index 0000000..0daaa24 --- /dev/null +++ b/fit.cpp @@ -0,0 +1,146 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit.hpp" + +/////////////////////////////////////////////////////////////////////// +// Private Definitions +/////////////////////////////////////////////////////////////////////// + +namespace fit +{ + +/////////////////////////////////////////////////////////////////////// +// Public Constants +/////////////////////////////////////////////////////////////////////// + +const FIT_UINT8 baseTypeSizes[FIT_BASE_TYPES] = + { + sizeof(FIT_ENUM), + sizeof(FIT_SINT8), + sizeof(FIT_UINT8), + sizeof(FIT_SINT16), + sizeof(FIT_UINT16), + sizeof(FIT_SINT32), + sizeof(FIT_UINT32), + sizeof(FIT_STRING), + sizeof(FIT_FLOAT32), + sizeof(FIT_FLOAT64), + sizeof(FIT_UINT8Z), + sizeof(FIT_UINT16Z), + sizeof(FIT_UINT32Z), + sizeof(FIT_BYTE), + sizeof(FIT_SINT64), + sizeof(FIT_UINT64), + sizeof(FIT_UINT64Z), + }; + +union FIT_FLOAT + { + FIT_UINT8 uint8_value[8]; + FIT_FLOAT64 float64_value; + FIT_FLOAT32 float32_value; + }; + +static const FIT_FLOAT floatInvalid = + { + { + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF, + 0xFF + } + }; + +const FIT_ENUM enumInvalid = FIT_ENUM_INVALID; +const FIT_SINT8 sint8Invalid = FIT_SINT8_INVALID; +const FIT_UINT8 uint8Invalid = FIT_UINT8_INVALID; +const FIT_SINT16 sint16Invalid = FIT_SINT16_INVALID; +const FIT_UINT16 uint16Invalid = FIT_UINT16_INVALID; +const FIT_SINT32 sint32Invalid = FIT_SINT32_INVALID; +const FIT_UINT32 uint32Invalid = FIT_UINT32_INVALID; +const FIT_STRING stringInvalid = FIT_STRING_INVALID; +const FIT_UINT8Z uint8zInvalid = FIT_UINT8Z_INVALID; +const FIT_UINT16Z uint16zInvalid = FIT_UINT16Z_INVALID; +const FIT_UINT32Z uint32zInvalid = FIT_UINT32Z_INVALID; +const FIT_BYTE byteInvalid = FIT_BYTE_INVALID; +const FIT_SINT64 sint64Invalid = FIT_SINT64_INVALID; +const FIT_UINT64 uint64Invalid = FIT_UINT64_INVALID; +const FIT_UINT64Z uint64zInvalid = FIT_UINT64Z_INVALID; + +const FIT_UINT8 *baseTypeInvalids[FIT_BASE_TYPES] = + { + (FIT_UINT8 *)&enumInvalid, + (FIT_UINT8 *)&sint8Invalid, + (FIT_UINT8 *)&uint8Invalid, + (FIT_UINT8 *)&sint16Invalid, + (FIT_UINT8 *)&uint16Invalid, + (FIT_UINT8 *)&sint32Invalid, + (FIT_UINT8 *)&uint32Invalid, + (FIT_UINT8 *)&stringInvalid, + (FIT_UINT8 *)&floatInvalid.float32_value, + (FIT_UINT8 *)&floatInvalid.float64_value, + (FIT_UINT8 *)&uint8zInvalid, + (FIT_UINT8 *)&uint16zInvalid, + (FIT_UINT8 *)&uint32zInvalid, + (FIT_UINT8 *)&byteInvalid, + (FIT_UINT8 *)&sint64Invalid, + (FIT_UINT8 *)&uint64Invalid, + (FIT_UINT8 *)&uint64zInvalid, + }; + +const std::map versionMap +{ + { ProtocolVersion::V10, DetailedProtocolVersion( 1, 0 ) }, + { ProtocolVersion::V20, DetailedProtocolVersion( 2, 0 ) } +}; + +/////////////////////////////////////////////////////////////////////// +// Public Functions +/////////////////////////////////////////////////////////////////////// + +DetailedProtocolVersion::DetailedProtocolVersion(FIT_UINT8 major, FIT_UINT8 minor) +{ + version = ( major << FIT_PROTOCOL_VERSION_MAJOR_SHIFT ) | minor; +} + +FIT_UINT8 DetailedProtocolVersion::GetMajorVersion() const +{ + return ( version & FIT_PROTOCOL_VERSION_MAJOR_MASK ) >> FIT_PROTOCOL_VERSION_MAJOR_SHIFT; +} + +FIT_UINT8 DetailedProtocolVersion::GetMinorVersion() const +{ + return version & FIT_PROTOCOL_VERSION_MINOR_MASK; +} + +FIT_UINT8 DetailedProtocolVersion::GetVersionByte() const +{ + return version; +} + +FIT_UINT8 GetArch(void) +{ + const FIT_UINT16 arch = 0x0100; + return (*(FIT_UINT8 *)&arch); +} + +} // namespace fit + +#if defined(FIT_CPP_INCLUDE_C) + // Include C Implementation + #include "fit.c" +#endif diff --git a/fit.hpp b/fit.hpp new file mode 100644 index 0000000..629b703 --- /dev/null +++ b/fit.hpp @@ -0,0 +1,353 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + + + +#if !defined(FIT_HPP) +#define FIT_HPP +#include + +#include "fit_config.hpp" +#if defined(FIT_CPP_INCLUDE_C) + #include "fit.h" +#endif + +#include +#include + +#if !defined(FIT_CPP_INCLUDE_C) + +#if defined(FIT_USE_STDINT_H) + #include +#endif + +#endif // !defined(FIT_CPP_INCLUDE_C) + +#ifdef __GNUC__ + #define DEPRECATED(mesg) __attribute__((deprecated(mesg))) +#elif defined(_MSC_VER) + #define DEPRECATED(mesg) __declspec(deprecated(mesg)) +#else +#define DEPRECATED(mesg) +#endif + +#if !defined(FIT_CPP_INCLUDE_C) + +namespace fit +{ +#if defined(FIT_USE_STDINT_H) + typedef ::int8_t int8_t; + typedef ::int16_t int16_t; + typedef ::int32_t int32_t; + typedef ::int64_t int64_t; + typedef ::uint8_t uint8_t; + typedef ::uint16_t uint16_t; + typedef ::uint32_t uint32_t; + typedef ::uint64_t uint64_t; +#else + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned long uint32_t; + typedef unsigned long long uint64_t; + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed long int32_t; + typedef signed long long int64_t; +#endif +} + +/////////////////////////////////////////////////////////////////////// +// Version +/////////////////////////////////////////////////////////////////////// +#endif // !defined(FIT_CPP_INCLUDE_C) + +// Non-backwards compatible changes. Decode compatible with this version and earlier. +#define FIT_PROTOCOL_VERSION_MAJOR ::fit::versionMap.at( ::fit::ProtocolVersion::V20 ).GetMajorVersion() +// Backwards compatible changes. +#define FIT_PROTOCOL_VERSION_MINOR ::fit::versionMap.at( ::fit::ProtocolVersion::V20 ).GetMinorVersion() +#define FIT_PROTOCOL_VERSION_MAJOR_SHIFT 4 +#define FIT_PROTOCOL_VERSION_MAJOR_MASK ((FIT_UINT8) (0x0F << FIT_PROTOCOL_VERSION_MAJOR_SHIFT)) +#define FIT_PROTOCOL_VERSION_MINOR_MASK ((FIT_UINT8) 0x0F) +#define FIT_PROTOCOL_VERSION ::fit::versionMap.at( ::fit::ProtocolVersion::V20 ).GetVersionByte() + +#define FIT_PROFILE_VERSION_MAJOR 21 +#define FIT_PROFILE_VERSION_MINOR 188 +#define FIT_PROFILE_VERSION_SCALE 1000 +#define FIT_PROFILE_VERSION ((FIT_UINT16) (FIT_PROFILE_VERSION_MAJOR * FIT_PROFILE_VERSION_SCALE + FIT_PROFILE_VERSION_MINOR)) + +#define FIT_HEADER_SIZE_NO_CRC 12 +#define FIT_HEADER_SIZE_WITH_CRC 14 + +/////////////////////////////////////////////////////////////////////// +// Type Definitions +/////////////////////////////////////////////////////////////////////// +#if !defined(FIT_CPP_INCLUDE_C) + +#define FIT_ANTFS_FILE_DATA_TYPE 128 + +#define FIT_BASE_TYPE_ENDIAN_FLAG ((FIT_UINT8)0x80) +#define FIT_BASE_TYPE_RESERVED ((FIT_UINT8)0x60) +#define FIT_BASE_TYPE_NUM_MASK ((FIT_UINT8)0x1F) + +typedef ::fit::uint8_t FIT_ENUM; +typedef const FIT_ENUM * FIT_CONST_ENUM_PTR; +#define FIT_ENUM_INVALID ((FIT_ENUM)0xFF) +#define FIT_BASE_TYPE_ENUM ((FIT_UINT8)0x00) + +typedef ::fit::int8_t FIT_SINT8; +typedef const FIT_SINT8 * FIT_CONST_SINT8_PTR; +#define FIT_SINT8_INVALID ((FIT_SINT8)0x7F) +#define FIT_BASE_TYPE_SINT8 ((FIT_UINT8)0x01) + +typedef ::fit::uint8_t FIT_UINT8; +typedef const FIT_UINT8 * FIT_CONST_UINT8_PTR; +#define FIT_UINT8_INVALID ((FIT_UINT8)0xFF) +#define FIT_BASE_TYPE_UINT8 ((FIT_UINT8)0x02) + +typedef ::fit::int16_t FIT_SINT16; +typedef const FIT_SINT16 * FIT_CONST_SINT16_PTR; +#define FIT_SINT16_INVALID ((FIT_SINT16)0x7FFF) +#define FIT_BASE_TYPE_SINT16 ((FIT_UINT8)0x83) + +typedef ::fit::uint16_t FIT_UINT16; +typedef const FIT_UINT16 * FIT_CONST_UINT16_PTR; +#define FIT_UINT16_INVALID ((FIT_UINT16)0xFFFF) +#define FIT_BASE_TYPE_UINT16 ((FIT_UINT8)0x84) + +typedef ::fit::int32_t FIT_SINT32; +typedef const FIT_SINT32 * FIT_CONST_SINT32_PTR; +#define FIT_SINT32_INVALID ((FIT_SINT32)0x7FFFFFFF) +#define FIT_BASE_TYPE_SINT32 ((FIT_UINT8)0x85) + +typedef ::fit::uint32_t FIT_UINT32; +typedef const FIT_UINT32 * FIT_CONST_UINT32_PTR; +#define FIT_UINT32_INVALID ((FIT_UINT32)0xFFFFFFFF) +#define FIT_BASE_TYPE_UINT32 ((FIT_UINT8)0x86) + +typedef char FIT_STRING; // UTF-8 null terminated string +typedef const FIT_STRING * FIT_CONST_STRING_PTR; +#define FIT_STRING_INVALID ((FIT_STRING)0x00) +#define FIT_BASE_TYPE_STRING ((FIT_UINT8)0x07) + +#endif // !defined(FIT_CPP_INCLUDE_C) + +typedef float FIT_FLOAT32; +typedef const FIT_FLOAT32 * FIT_CONST_FLOAT32_PTR; +#define FIT_FLOAT32_INVALID ((FIT_FLOAT32)*((FIT_FLOAT32*)::fit::baseTypeInvalids[FIT_BASE_TYPE_FLOAT32 & FIT_BASE_TYPE_NUM_MASK])) +#define FIT_BASE_TYPE_FLOAT32 ((FIT_UINT8)0x88) + +typedef double FIT_FLOAT64; +typedef const FIT_FLOAT64 * FIT_CONST_FLOAT64_PTR; +#define FIT_FLOAT64_INVALID ((FIT_FLOAT64)*((FIT_FLOAT64*)::fit::baseTypeInvalids[FIT_BASE_TYPE_FLOAT64 & FIT_BASE_TYPE_NUM_MASK])) +#define FIT_BASE_TYPE_FLOAT64 ((FIT_UINT8)0x89) + +#if !defined(FIT_CPP_INCLUDE_C) + +typedef ::fit::uint8_t FIT_UINT8Z; +typedef const FIT_UINT8Z * FIT_CONST_UINT8Z_PTR; +#define FIT_UINT8Z_INVALID ((FIT_UINT8Z)0x00) +#define FIT_BASE_TYPE_UINT8Z ((FIT_UINT8)0x0A) + +typedef ::fit::uint16_t FIT_UINT16Z; +typedef const FIT_UINT16Z * FIT_CONST_UINT16Z_PTR; +#define FIT_UINT16Z_INVALID ((FIT_UINT16Z)0x0000) +#define FIT_BASE_TYPE_UINT16Z ((FIT_UINT8)0x8B) + +typedef ::fit::uint32_t FIT_UINT32Z; +typedef const FIT_UINT32Z * FIT_CONST_UINT32Z_PTR; +#define FIT_UINT32Z_INVALID ((FIT_UINT32Z)0x00000000) +#define FIT_BASE_TYPE_UINT32Z ((FIT_UINT8)0x8C) + +typedef ::fit::uint8_t FIT_BYTE; +typedef const FIT_BYTE * FIT_CONST_BYTE_PTR; +#define FIT_BYTE_INVALID ((FIT_BYTE)0xFF) // Field is invalid if all bytes are invalid. +#define FIT_BASE_TYPE_BYTE ((FIT_UINT8)0x0D) + +typedef ::fit::int64_t FIT_SINT64; +typedef const FIT_SINT64 * FIT_CONST_SINT64_PTR; +#define FIT_SINT64_INVALID ((FIT_SINT64)0x7FFFFFFFFFFFFFFFL) +#define FIT_BASE_TYPE_SINT64 ((FIT_UINT8)0x8E) + +typedef ::fit::uint64_t FIT_UINT64; +typedef const FIT_UINT64 * FIT_CONST_UINT64_PTR; +#define FIT_UINT64_INVALID ((FIT_UINT64)0xFFFFFFFFFFFFFFFFL) +#define FIT_BASE_TYPE_UINT64 ((FIT_UINT8)0x8F) + +typedef ::fit::uint64_t FIT_UINT64Z; +typedef const FIT_UINT64Z * FIT_CONST_UINT64Z_PTR; +#define FIT_UINT64Z_INVALID ((FIT_UINT64Z)0x0000000000000000L) +#define FIT_BASE_TYPE_UINT64Z ((FIT_UINT8)0x90) + +#define FIT_BASE_TYPES 17 + +typedef FIT_ENUM FIT_BOOL; +#define FIT_BOOL_INVALID FIT_ENUM_INVALID +#define FIT_BOOL_FALSE ((FIT_BOOL)0) +#define FIT_BOOL_TRUE ((FIT_BOOL)1) +#define FIT_FALSE FIT_BOOL_FALSE +#define FIT_TRUE FIT_BOOL_TRUE +#define FIT_NULL nullptr + +typedef FIT_UINT32 (*FIT_READ_BYTES_FUNC)(void *, FIT_UINT32, FIT_UINT32); +#define FIT_MESG_DEF_HEADER_SIZE FIT_STRUCT_OFFSET(fields, FIT_MESG_DEF) + + +/////////////////////////////////////////////////////////////////////// +// File Header +/////////////////////////////////////////////////////////////////////// + +typedef struct +{ + FIT_UINT8 header_size; // FIT_FILE_HDR_SIZE (size of this structure) + FIT_UINT8 protocol_version; // FIT_PROTOCOL_VERSION + FIT_UINT16 profile_version; // FIT_PROFILE_VERSION + FIT_UINT32 data_size; // Does not include file header or crc. Little endian format. + FIT_UINT8 data_type[4]; // ".FIT" + FIT_UINT16 crc; // CRC of this file header in little endian format. +} FIT_FILE_HDR; + +#define FIT_FILE_HDR_SIZE 14 + + +/////////////////////////////////////////////////////////////////////// +// Record Definitions +/////////////////////////////////////////////////////////////////////// + +#define FIT_HDR_SIZE 1 +#define FIT_HDR_TIME_REC_BIT ((FIT_UINT8) 0x80) +#define FIT_HDR_TIME_TYPE_MASK ((FIT_UINT8) 0x60) +#define FIT_HDR_TIME_TYPE_SHIFT 5 +#define FIT_HDR_TIME_OFFSET_MASK ((FIT_UINT8) 0x1F) +#define FIT_HDR_TYPE_DEF_BIT ((FIT_UINT8) 0x40) +#define FIT_HDR_TYPE_MASK ((FIT_UINT8) 0x0F) +#define FIT_MAX_LOCAL_MESGS (FIT_HDR_TYPE_MASK + 1) + +#endif // !defined(FIT_CPP_INCLUDE_C) + +#define FIT_HDR_DEV_FIELD_BIT ((FIT_UINT8) 0x20) + +#if !defined(FIT_CPP_INCLUDE_C) + +/////////////////////////////////////////////////////////////////////// +// Message Definitions +/////////////////////////////////////////////////////////////////////// + +typedef struct +{ + FIT_UINT8 field_def_num; + FIT_UINT8 size; + FIT_UINT8 base_type; +} FIT_FIELD_DEF; + +#define FIT_FIELD_DEF_SIZE 3 + +typedef struct +{ + FIT_UINT8 reserved_1; + FIT_UINT8 arch; + FIT_UINT16 global_mesg_num; + FIT_UINT8 num_fields; + FIT_UINT8 fields[1]; +} FIT_MESG_DEF; + +#define FIT_MAX_MESG_SIZE ((FIT_UINT16)65535) + +#define FIT_ARCH_ENDIAN_MASK ((FIT_UINT8)0x01) +#define FIT_ARCH_ENDIAN_LITTLE ((FIT_UINT8)0) +#define FIT_ARCH_ENDIAN_BIG ((FIT_UINT8)1) + + +/////////////////////////////////////////////////////////////////////// +// Field Definitions +/////////////////////////////////////////////////////////////////////// + +#define FIT_MAX_FIELD_SIZE ((FIT_UINT8)255) +#define FIT_FIELD_NUM_INVALID ((FIT_UINT8)0xFF) +#define FIT_FIELD_NUM_MESSAGE_INDEX ((FIT_UINT8)254) +#define FIT_FIELD_NUM_TIMESTAMP ((FIT_UINT8)253) + +#define FIT_MESSAGE_INDEX_FIELD_NUM FIT_FIELD_NUM_MESSAGE_INDEX // For reverse compatibility only. Use FIT_FIELD_NUM_MESSAGE_INDEX instead. +#define FIT_TIMESTAMP_FIELD_NUM FIT_FIELD_NUM_TIMESTAMP // For reverse compatibility only. Use FIT_FIELD_NUM_TIMESTAMP instead. + + +/////////////////////////////////////////////////////////////////////// +// Macros +/////////////////////////////////////////////////////////////////////// + +#define FIT_STRUCT_OFFSET(MEMBER, STRUCT_TYPE) ( ((FIT_UINT8 *) &(((STRUCT_TYPE *) FIT_NULL)->MEMBER)) - ((FIT_UINT8 *) (FIT_NULL)) ) // Computes the byte offset of a member in a file. Compiles to a constant. + +// Offset of message in file, not including file header. +#define FIT_MESG_OFFSET(MESG_MEMBER, MESG_INDEX, MESG_SIZE, FILE) (FIT_STRUCT_OFFSET(MESG_MEMBER, FILE) + MESG_INDEX * (FIT_HDR_SIZE + MESG_SIZE) + FIT_HDR_SIZE) // Computes the byte offset of a message in a file structure. Compiles to a constant. +#define FIT_MESG_DEF_OFFSET(MESG_DEF_MEMBER, FILE) (FIT_STRUCT_OFFSET(MESG_DEF_MEMBER, FILE) + FIT_HDR_SIZE) // Computes the byte offset of a message definition in a file structure. Compiles to a constant. +#define FIT_MESG_DEF_FIELD_OFFSET(FIELD_MEMBER, FIELD_INDEX) (FIT_STRUCT_OFFSET(FIELD_MEMBER, FIT_FIELD_DEF) + FIT_FIELD_DEF_SIZE * FIELD_INDEX) // Computes the byte offset of a field definition member. Compiles to a constant. + +// Offset of message in file including file header. +#define FIT_FILE_MESG_OFFSET(MESG_MEMBER, MESG_INDEX, MESG_SIZE, FILE) (FIT_FILE_HDR_SIZE + FIT_MESG_OFFSET(MESG_MEMBER, MESG_INDEX, MESG_SIZE, FILE)) +#define FIT_FILE_MESG_DEF_OFFSET(MESG_DEF_MEMBER, FILE) (FIT_MESG_DEF_OFFSET(MESG_DEF_MEMBER, FILE)) +#define FIT_FILE_MESG_DEF_FIELD_OFFSET(FIELD_MEMBER, FIELD_INDEX) (FIT_MESG_DEF_FIELD_OFFSET(FIELD_MEMBER, FIELD_INDEX)) + +#endif // !defined(FIT_CPP_INCLUDE_C) + +/////////////////////////////////////////////////////////////////////// +// C++ Specific Definitions +/////////////////////////////////////////////////////////////////////// + +typedef std::wstring FIT_WSTRING; // Returned by message/field "Get" APIs and required by "Set" APIs. Encoding defined in fit_config.hpp. +typedef const FIT_WSTRING * FIT_CONST_WSTRING_PTR; +#define FIT_WSTRING_INVALID (FIT_WSTRING()) + + +namespace fit +{ + +enum class ProtocolVersion +{ + V10, + V20 +}; + +class DetailedProtocolVersion +{ +public: + DetailedProtocolVersion( FIT_UINT8 major, FIT_UINT8 minor ); + + FIT_UINT8 GetMajorVersion() const; + FIT_UINT8 GetMinorVersion() const; + FIT_UINT8 GetVersionByte() const; + +private: + FIT_UINT8 version; +}; + +/////////////////////////////////////////////////////////////////////// +// Public Constants +/////////////////////////////////////////////////////////////////////// + +const extern FIT_UINT8 baseTypeSizes[FIT_BASE_TYPES]; +const extern FIT_UINT8 *baseTypeInvalids[FIT_BASE_TYPES]; +const extern std::map versionMap; + + +/////////////////////////////////////////////////////////////////////// +// Public Functions +/////////////////////////////////////////////////////////////////////// + +FIT_UINT8 GetArch(void); +/////////////////////////////////////////////////////////////////////// +// Returns architecture type. +// Includes runtime check for little or big endian. +// See FIT_MESG_DEF->arch and FIT_ARCH_*. +/////////////////////////////////////////////////////////////////////// + +} // namespace fit + +#endif // !defined(FIT_HPP) diff --git a/fit_aad_accel_features_mesg.hpp b/fit_aad_accel_features_mesg.hpp new file mode 100644 index 0000000..c3e7ee8 --- /dev/null +++ b/fit_aad_accel_features_mesg.hpp @@ -0,0 +1,248 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_AAD_ACCEL_FEATURES_MESG_HPP) +#define FIT_AAD_ACCEL_FEATURES_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class AadAccelFeaturesMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Time = 0; + static const FIT_UINT8 EnergyTotal = 1; + static const FIT_UINT8 ZeroCrossCnt = 2; + static const FIT_UINT8 Instance = 3; + static const FIT_UINT8 TimeAboveThreshold = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + AadAccelFeaturesMesg(void) : Mesg(Profile::MESG_AAD_ACCEL_FEATURES) + { + } + + AadAccelFeaturesMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time field + // Units: s + // Comment: Time interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTime(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time field + // Units: s + // Comment: Time interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetTime(FIT_UINT16 time) + { + SetFieldUINT16Value(0, time, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of energy_total field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnergyTotalValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns energy_total field + // Comment: Total accelerometer energy in the interval + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetEnergyTotal(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set energy_total field + // Comment: Total accelerometer energy in the interval + /////////////////////////////////////////////////////////////////////// + void SetEnergyTotal(FIT_UINT32 energyTotal) + { + SetFieldUINT32Value(1, energyTotal, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of zero_cross_cnt field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsZeroCrossCntValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns zero_cross_cnt field + // Comment: Count of zero crossings + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetZeroCrossCnt(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set zero_cross_cnt field + // Comment: Count of zero crossings + /////////////////////////////////////////////////////////////////////// + void SetZeroCrossCnt(FIT_UINT16 zeroCrossCnt) + { + SetFieldUINT16Value(2, zeroCrossCnt, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of instance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsInstanceValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns instance field + // Comment: Instance ID of zero crossing algorithm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetInstance(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set instance field + // Comment: Instance ID of zero crossing algorithm + /////////////////////////////////////////////////////////////////////// + void SetInstance(FIT_UINT8 instance) + { + SetFieldUINT8Value(3, instance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_above_threshold field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeAboveThresholdValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_above_threshold field + // Units: s + // Comment: Total accelerometer time above threshold in the interval + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeAboveThreshold(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_above_threshold field + // Units: s + // Comment: Total accelerometer time above threshold in the interval + /////////////////////////////////////////////////////////////////////// + void SetTimeAboveThreshold(FIT_FLOAT32 timeAboveThreshold) + { + SetFieldFLOAT32Value(4, timeAboveThreshold, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_AAD_ACCEL_FEATURES_MESG_HPP) diff --git a/fit_aad_accel_features_mesg_listener.hpp b/fit_aad_accel_features_mesg_listener.hpp new file mode 100644 index 0000000..4a07277 --- /dev/null +++ b/fit_aad_accel_features_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_AAD_ACCEL_FEATURES_MESG_LISTENER_HPP) +#define FIT_AAD_ACCEL_FEATURES_MESG_LISTENER_HPP + +#include "fit_aad_accel_features_mesg.hpp" + +namespace fit +{ + +class AadAccelFeaturesMesgListener +{ +public: + virtual ~AadAccelFeaturesMesgListener() {} + virtual void OnMesg(AadAccelFeaturesMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_AAD_ACCEL_FEATURES_MESG_LISTENER_HPP) diff --git a/fit_accelerometer_data_mesg.hpp b/fit_accelerometer_data_mesg.hpp new file mode 100644 index 0000000..647c539 --- /dev/null +++ b/fit_accelerometer_data_mesg.hpp @@ -0,0 +1,554 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ACCELEROMETER_DATA_MESG_HPP) +#define FIT_ACCELEROMETER_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class AccelerometerDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SampleTimeOffset = 1; + static const FIT_UINT8 AccelX = 2; + static const FIT_UINT8 AccelY = 3; + static const FIT_UINT8 AccelZ = 4; + static const FIT_UINT8 CalibratedAccelX = 5; + static const FIT_UINT8 CalibratedAccelY = 6; + static const FIT_UINT8 CalibratedAccelZ = 7; + static const FIT_UINT8 CompressedCalibratedAccelX = 8; + static const FIT_UINT8 CompressedCalibratedAccelY = 9; + static const FIT_UINT8 CompressedCalibratedAccelZ = 10; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + AccelerometerDataMesg(void) : Mesg(Profile::MESG_ACCELEROMETER_DATA) + { + } + + AccelerometerDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of sample_time_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSampleTimeOffset(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sample_time_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSampleTimeOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the accelerometer sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in accel_x and accel_y and accel_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSampleTimeOffset(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the accelerometer sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in accel_x and accel_y and accel_z + /////////////////////////////////////////////////////////////////////// + void SetSampleTimeOffset(FIT_UINT8 index, FIT_UINT16 sampleTimeOffset) + { + SetFieldUINT16Value(1, sampleTimeOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelX(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelXValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_x field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAccelX(FIT_UINT8 index) const + { + return GetFieldUINT16Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_x field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetAccelX(FIT_UINT8 index, FIT_UINT16 accelX) + { + SetFieldUINT16Value(2, accelX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelY(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelYValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_y field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAccelY(FIT_UINT8 index) const + { + return GetFieldUINT16Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_y field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetAccelY(FIT_UINT8 index, FIT_UINT16 accelY) + { + SetFieldUINT16Value(3, accelY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelZ(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelZValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_z field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAccelZ(FIT_UINT8 index) const + { + return GetFieldUINT16Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_z field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetAccelZ(FIT_UINT8 index, FIT_UINT16 accelZ) + { + SetFieldUINT16Value(4, accelZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_accel_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedAccelX(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_accel_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedAccelXValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_accel_x field + // Units: g + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedAccelX(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_accel_x field + // Units: g + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedAccelX(FIT_UINT8 index, FIT_FLOAT32 calibratedAccelX) + { + SetFieldFLOAT32Value(5, calibratedAccelX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_accel_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedAccelY(void) const + { + return GetFieldNumValues(6, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_accel_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedAccelYValid(FIT_UINT8 index) const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_accel_y field + // Units: g + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedAccelY(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(6, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_accel_y field + // Units: g + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedAccelY(FIT_UINT8 index, FIT_FLOAT32 calibratedAccelY) + { + SetFieldFLOAT32Value(6, calibratedAccelY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_accel_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedAccelZ(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_accel_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedAccelZValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_accel_z field + // Units: g + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedAccelZ(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_accel_z field + // Units: g + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedAccelZ(FIT_UINT8 index, FIT_FLOAT32 calibratedAccelZ) + { + SetFieldFLOAT32Value(7, calibratedAccelZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of compressed_calibrated_accel_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCompressedCalibratedAccelX(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of compressed_calibrated_accel_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCompressedCalibratedAccelXValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns compressed_calibrated_accel_x field + // Units: mG + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + FIT_SINT16 GetCompressedCalibratedAccelX(FIT_UINT8 index) const + { + return GetFieldSINT16Value(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set compressed_calibrated_accel_x field + // Units: mG + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + void SetCompressedCalibratedAccelX(FIT_UINT8 index, FIT_SINT16 compressedCalibratedAccelX) + { + SetFieldSINT16Value(8, compressedCalibratedAccelX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of compressed_calibrated_accel_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCompressedCalibratedAccelY(void) const + { + return GetFieldNumValues(9, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of compressed_calibrated_accel_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCompressedCalibratedAccelYValid(FIT_UINT8 index) const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns compressed_calibrated_accel_y field + // Units: mG + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + FIT_SINT16 GetCompressedCalibratedAccelY(FIT_UINT8 index) const + { + return GetFieldSINT16Value(9, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set compressed_calibrated_accel_y field + // Units: mG + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + void SetCompressedCalibratedAccelY(FIT_UINT8 index, FIT_SINT16 compressedCalibratedAccelY) + { + SetFieldSINT16Value(9, compressedCalibratedAccelY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of compressed_calibrated_accel_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCompressedCalibratedAccelZ(void) const + { + return GetFieldNumValues(10, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of compressed_calibrated_accel_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCompressedCalibratedAccelZValid(FIT_UINT8 index) const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns compressed_calibrated_accel_z field + // Units: mG + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + FIT_SINT16 GetCompressedCalibratedAccelZ(FIT_UINT8 index) const + { + return GetFieldSINT16Value(10, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set compressed_calibrated_accel_z field + // Units: mG + // Comment: Calibrated accel reading + /////////////////////////////////////////////////////////////////////// + void SetCompressedCalibratedAccelZ(FIT_UINT8 index, FIT_SINT16 compressedCalibratedAccelZ) + { + SetFieldSINT16Value(10, compressedCalibratedAccelZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ACCELEROMETER_DATA_MESG_HPP) diff --git a/fit_accelerometer_data_mesg_listener.hpp b/fit_accelerometer_data_mesg_listener.hpp new file mode 100644 index 0000000..68664c8 --- /dev/null +++ b/fit_accelerometer_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ACCELEROMETER_DATA_MESG_LISTENER_HPP) +#define FIT_ACCELEROMETER_DATA_MESG_LISTENER_HPP + +#include "fit_accelerometer_data_mesg.hpp" + +namespace fit +{ + +class AccelerometerDataMesgListener +{ +public: + virtual ~AccelerometerDataMesgListener() {} + virtual void OnMesg(AccelerometerDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ACCELEROMETER_DATA_MESG_LISTENER_HPP) diff --git a/fit_accumulated_field.cpp b/fit_accumulated_field.cpp new file mode 100644 index 0000000..1d9b9d1 --- /dev/null +++ b/fit_accumulated_field.cpp @@ -0,0 +1,45 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_accumulated_field.hpp" + +namespace fit +{ + +AccumulatedField::AccumulatedField() + : lastValue(0), accumulatedValue(0) +{ +} + +AccumulatedField::AccumulatedField(const FIT_UINT16 newMesgNum, const FIT_UINT8 destFieldNum) + : mesgNum(newMesgNum), destFieldNum(destFieldNum), lastValue(0), accumulatedValue(0) +{ +} + +FIT_UINT32 AccumulatedField::Accumulate(const FIT_UINT32 value, const FIT_UINT8 bits) +{ + FIT_UINT32 mask = ((FIT_UINT32) 1 << bits) - 1; + + accumulatedValue += (value - lastValue) & mask; + lastValue = value; + + return accumulatedValue; +} + +FIT_UINT32 AccumulatedField::Set(FIT_UINT32 value) +{ + accumulatedValue = value; + this->lastValue = value; + return accumulatedValue; +} + +} // namespace fit diff --git a/fit_accumulated_field.hpp b/fit_accumulated_field.hpp new file mode 100644 index 0000000..ec8b49b --- /dev/null +++ b/fit_accumulated_field.hpp @@ -0,0 +1,41 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ACCUMULATED_FIELD_HPP) +#define FIT_ACCUMULATED_FIELD_HPP + +#include "fit.hpp" + +namespace fit +{ + +class AccumulatedField +{ + public: + FIT_UINT16 mesgNum; + FIT_UINT8 destFieldNum; //Field# to accumulate into + FIT_UINT32 lastValue; + FIT_UINT32 accumulatedValue; + + AccumulatedField(); + AccumulatedField(const FIT_UINT16 newMesgNum, const FIT_UINT8 destFieldNum); + FIT_UINT32 Accumulate(const FIT_UINT32 value, const FIT_UINT8 bits); + FIT_UINT32 Set(FIT_UINT32 value); + + private: +}; + +} // namespace fit + +#endif // defined(FIT_ACCUMULATED_FIELD_HPP) + + diff --git a/fit_accumulator.cpp b/fit_accumulator.cpp new file mode 100644 index 0000000..3b37487 --- /dev/null +++ b/fit_accumulator.cpp @@ -0,0 +1,56 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_accumulator.hpp" + +namespace fit +{ + +FIT_UINT32 Accumulator::Accumulate(const FIT_UINT16 mesgNum, const FIT_UINT8 destFieldNum, const FIT_UINT32 value, const FIT_UINT8 bits) +{ + int i; + AccumulatedField accumField; + + for (i = 0; i < (int)fields.size(); i++) + { + accumField = fields.at(i); + if ( ( accumField.mesgNum == mesgNum ) && ( accumField.destFieldNum == destFieldNum ) ) + break; + } + + if (i == (int)fields.size()) { + fields.push_back(AccumulatedField(mesgNum, destFieldNum)); + } + + return fields[i].Accumulate(value, bits); +} + +void Accumulator::Set(const FIT_UINT16 mesgNum, const FIT_UINT8 destFieldNum, const FIT_UINT32 value) +{ + int i; + AccumulatedField accumField; + + for (i = 0; i < (int)fields.size(); i++) + { + accumField = fields.at(i); + if ( ( accumField.mesgNum == mesgNum ) && ( accumField.destFieldNum == destFieldNum ) ) + break; + } + + if (i == (int)fields.size()) { + accumField = AccumulatedField(mesgNum, destFieldNum); + fields.push_back(accumField); + } + fields[i].Set(value); +} + +} // namespace fit diff --git a/fit_accumulator.hpp b/fit_accumulator.hpp new file mode 100644 index 0000000..000022b --- /dev/null +++ b/fit_accumulator.hpp @@ -0,0 +1,35 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ACCUMULATOR_HPP) +#define FIT_ACCUMULATOR_HPP + +#include +#include "fit_accumulated_field.hpp" + +namespace fit +{ + +class Accumulator +{ + public: + FIT_UINT32 Accumulate(const FIT_UINT16 mesgNum, const FIT_UINT8 destFieldNum, const FIT_UINT32 value, const FIT_UINT8 bits); + void Set(const FIT_UINT16 mesgNum, const FIT_UINT8 destFieldNum, const FIT_UINT32 value ); + + private: + std::vector fields; +}; + +} // namespace fit + +#endif // defined(FIT_ACCUMULATOR_HPP) + diff --git a/fit_activity_mesg.hpp b/fit_activity_mesg.hpp new file mode 100644 index 0000000..4cf444d --- /dev/null +++ b/fit_activity_mesg.hpp @@ -0,0 +1,305 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ACTIVITY_MESG_HPP) +#define FIT_ACTIVITY_MESG_HPP + +#include "fit_mesg.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class ActivityMesg : public Mesg, public MesgWithEvent +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TotalTimerTime = 0; + static const FIT_UINT8 NumSessions = 1; + static const FIT_UINT8 Type = 2; + static const FIT_UINT8 Event = 3; + static const FIT_UINT8 EventType = 4; + static const FIT_UINT8 LocalTimestamp = 5; + static const FIT_UINT8 EventGroup = 6; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ActivityMesg(void) : Mesg(Profile::MESG_ACTIVITY) + { + } + + ActivityMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + // Comment: Exclude pauses + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + // Comment: Exclude pauses + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(0, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_sessions field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumSessionsValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_sessions field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumSessions(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_sessions field + /////////////////////////////////////////////////////////////////////// + void SetNumSessions(FIT_UINT16 numSessions) + { + SetFieldUINT16Value(1, numSessions, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY GetType(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_ACTIVITY type) + { + SetFieldENUMValue(2, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT GetEvent(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event field + /////////////////////////////////////////////////////////////////////// + void SetEvent(FIT_EVENT event) + { + SetFieldENUMValue(3, event, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_type field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT_TYPE GetEventType(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_type field + /////////////////////////////////////////////////////////////////////// + void SetEventType(FIT_EVENT_TYPE eventType) + { + SetFieldENUMValue(4, eventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalTimestampValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns local_timestamp field + // Comment: timestamp epoch expressed in local time, used to convert activity timestamps to local time + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DATE_TIME GetLocalTimestamp(void) const + { + return GetFieldUINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_timestamp field + // Comment: timestamp epoch expressed in local time, used to convert activity timestamps to local time + /////////////////////////////////////////////////////////////////////// + void SetLocalTimestamp(FIT_LOCAL_DATE_TIME localTimestamp) + { + SetFieldUINT32Value(5, localTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_group field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventGroupValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_group field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventGroup(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_group field + /////////////////////////////////////////////////////////////////////// + void SetEventGroup(FIT_UINT8 eventGroup) + { + SetFieldUINT8Value(6, eventGroup, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ACTIVITY_MESG_HPP) diff --git a/fit_activity_mesg_listener.hpp b/fit_activity_mesg_listener.hpp new file mode 100644 index 0000000..ee70019 --- /dev/null +++ b/fit_activity_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ACTIVITY_MESG_LISTENER_HPP) +#define FIT_ACTIVITY_MESG_LISTENER_HPP + +#include "fit_activity_mesg.hpp" + +namespace fit +{ + +class ActivityMesgListener +{ +public: + virtual ~ActivityMesgListener() {} + virtual void OnMesg(ActivityMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ACTIVITY_MESG_LISTENER_HPP) diff --git a/fit_ant_channel_id_mesg.hpp b/fit_ant_channel_id_mesg.hpp new file mode 100644 index 0000000..98982cf --- /dev/null +++ b/fit_ant_channel_id_mesg.hpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ANT_CHANNEL_ID_MESG_HPP) +#define FIT_ANT_CHANNEL_ID_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class AntChannelIdMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 ChannelNumber = 0; + static const FIT_UINT8 DeviceType = 1; + static const FIT_UINT8 DeviceNumber = 2; + static const FIT_UINT8 TransmissionType = 3; + static const FIT_UINT8 DeviceIndex = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + AntChannelIdMesg(void) : Mesg(Profile::MESG_ANT_CHANNEL_ID) + { + } + + AntChannelIdMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of channel_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsChannelNumberValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns channel_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetChannelNumber(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set channel_number field + /////////////////////////////////////////////////////////////////////// + void SetChannelNumber(FIT_UINT8 channelNumber) + { + SetFieldUINT8Value(0, channelNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetDeviceType(void) const + { + return GetFieldUINT8ZValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_type field + /////////////////////////////////////////////////////////////////////// + void SetDeviceType(FIT_UINT8Z deviceType) + { + SetFieldUINT8ZValue(1, deviceType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceNumberValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetDeviceNumber(void) const + { + return GetFieldUINT16ZValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_number field + /////////////////////////////////////////////////////////////////////// + void SetDeviceNumber(FIT_UINT16Z deviceNumber) + { + SetFieldUINT16ZValue(2, deviceNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of transmission_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTransmissionTypeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns transmission_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetTransmissionType(void) const + { + return GetFieldUINT8ZValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set transmission_type field + /////////////////////////////////////////////////////////////////////// + void SetTransmissionType(FIT_UINT8Z transmissionType) + { + SetFieldUINT8ZValue(3, transmissionType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIndexValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_index field + /////////////////////////////////////////////////////////////////////// + FIT_DEVICE_INDEX GetDeviceIndex(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_index field + /////////////////////////////////////////////////////////////////////// + void SetDeviceIndex(FIT_DEVICE_INDEX deviceIndex) + { + SetFieldUINT8Value(4, deviceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ANT_CHANNEL_ID_MESG_HPP) diff --git a/fit_ant_channel_id_mesg_listener.hpp b/fit_ant_channel_id_mesg_listener.hpp new file mode 100644 index 0000000..659ff63 --- /dev/null +++ b/fit_ant_channel_id_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ANT_CHANNEL_ID_MESG_LISTENER_HPP) +#define FIT_ANT_CHANNEL_ID_MESG_LISTENER_HPP + +#include "fit_ant_channel_id_mesg.hpp" + +namespace fit +{ + +class AntChannelIdMesgListener +{ +public: + virtual ~AntChannelIdMesgListener() {} + virtual void OnMesg(AntChannelIdMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ANT_CHANNEL_ID_MESG_LISTENER_HPP) diff --git a/fit_ant_rx_mesg.hpp b/fit_ant_rx_mesg.hpp new file mode 100644 index 0000000..8015baf --- /dev/null +++ b/fit_ant_rx_mesg.hpp @@ -0,0 +1,254 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ANT_RX_MESG_HPP) +#define FIT_ANT_RX_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class AntRxMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 FractionalTimestamp = 0; + static const FIT_UINT8 MesgId = 1; + static const FIT_UINT8 MesgData = 2; + static const FIT_UINT8 ChannelNumber = 3; + static const FIT_UINT8 Data = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + AntRxMesg(void) : Mesg(Profile::MESG_ANT_RX) + { + } + + AntRxMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fractional_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFractionalTimestampValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fractional_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFractionalTimestamp(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fractional_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetFractionalTimestamp(FIT_FLOAT32 fractionalTimestamp) + { + SetFieldFLOAT32Value(0, fractionalTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgIdValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_id field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetMesgId(void) const + { + return GetFieldBYTEValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_id field + /////////////////////////////////////////////////////////////////////// + void SetMesgId(FIT_BYTE mesgId) + { + SetFieldBYTEValue(1, mesgId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of mesg_data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMesgData(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_data field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetMesgData(FIT_UINT8 index) const + { + return GetFieldBYTEValue(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_data field + /////////////////////////////////////////////////////////////////////// + void SetMesgData(FIT_UINT8 index, FIT_BYTE mesgData) + { + SetFieldBYTEValue(2, mesgData, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of channel_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsChannelNumberValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns channel_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetChannelNumber(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set channel_number field + /////////////////////////////////////////////////////////////////////// + void SetChannelNumber(FIT_UINT8 channelNumber) + { + SetFieldUINT8Value(3, channelNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumData(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetData(FIT_UINT8 index) const + { + return GetFieldBYTEValue(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data field + /////////////////////////////////////////////////////////////////////// + void SetData(FIT_UINT8 index, FIT_BYTE data) + { + SetFieldBYTEValue(4, data, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ANT_RX_MESG_HPP) diff --git a/fit_ant_rx_mesg_listener.hpp b/fit_ant_rx_mesg_listener.hpp new file mode 100644 index 0000000..db45d44 --- /dev/null +++ b/fit_ant_rx_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ANT_RX_MESG_LISTENER_HPP) +#define FIT_ANT_RX_MESG_LISTENER_HPP + +#include "fit_ant_rx_mesg.hpp" + +namespace fit +{ + +class AntRxMesgListener +{ +public: + virtual ~AntRxMesgListener() {} + virtual void OnMesg(AntRxMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ANT_RX_MESG_LISTENER_HPP) diff --git a/fit_ant_tx_mesg.hpp b/fit_ant_tx_mesg.hpp new file mode 100644 index 0000000..a5c2859 --- /dev/null +++ b/fit_ant_tx_mesg.hpp @@ -0,0 +1,254 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ANT_TX_MESG_HPP) +#define FIT_ANT_TX_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class AntTxMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 FractionalTimestamp = 0; + static const FIT_UINT8 MesgId = 1; + static const FIT_UINT8 MesgData = 2; + static const FIT_UINT8 ChannelNumber = 3; + static const FIT_UINT8 Data = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + AntTxMesg(void) : Mesg(Profile::MESG_ANT_TX) + { + } + + AntTxMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fractional_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFractionalTimestampValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fractional_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFractionalTimestamp(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fractional_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetFractionalTimestamp(FIT_FLOAT32 fractionalTimestamp) + { + SetFieldFLOAT32Value(0, fractionalTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgIdValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_id field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetMesgId(void) const + { + return GetFieldBYTEValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_id field + /////////////////////////////////////////////////////////////////////// + void SetMesgId(FIT_BYTE mesgId) + { + SetFieldBYTEValue(1, mesgId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of mesg_data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMesgData(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_data field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetMesgData(FIT_UINT8 index) const + { + return GetFieldBYTEValue(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_data field + /////////////////////////////////////////////////////////////////////// + void SetMesgData(FIT_UINT8 index, FIT_BYTE mesgData) + { + SetFieldBYTEValue(2, mesgData, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of channel_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsChannelNumberValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns channel_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetChannelNumber(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set channel_number field + /////////////////////////////////////////////////////////////////////// + void SetChannelNumber(FIT_UINT8 channelNumber) + { + SetFieldUINT8Value(3, channelNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumData(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetData(FIT_UINT8 index) const + { + return GetFieldBYTEValue(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data field + /////////////////////////////////////////////////////////////////////// + void SetData(FIT_UINT8 index, FIT_BYTE data) + { + SetFieldBYTEValue(4, data, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ANT_TX_MESG_HPP) diff --git a/fit_ant_tx_mesg_listener.hpp b/fit_ant_tx_mesg_listener.hpp new file mode 100644 index 0000000..0bc9120 --- /dev/null +++ b/fit_ant_tx_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ANT_TX_MESG_LISTENER_HPP) +#define FIT_ANT_TX_MESG_LISTENER_HPP + +#include "fit_ant_tx_mesg.hpp" + +namespace fit +{ + +class AntTxMesgListener +{ +public: + virtual ~AntTxMesgListener() {} + virtual void OnMesg(AntTxMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ANT_TX_MESG_LISTENER_HPP) diff --git a/fit_aviation_attitude_mesg.hpp b/fit_aviation_attitude_mesg.hpp new file mode 100644 index 0000000..9c58725 --- /dev/null +++ b/fit_aviation_attitude_mesg.hpp @@ -0,0 +1,546 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_AVIATION_ATTITUDE_MESG_HPP) +#define FIT_AVIATION_ATTITUDE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class AviationAttitudeMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SystemTime = 1; + static const FIT_UINT8 Pitch = 2; + static const FIT_UINT8 Roll = 3; + static const FIT_UINT8 AccelLateral = 4; + static const FIT_UINT8 AccelNormal = 5; + static const FIT_UINT8 TurnRate = 6; + static const FIT_UINT8 Stage = 7; + static const FIT_UINT8 AttitudeStageComplete = 8; + static const FIT_UINT8 Track = 9; + static const FIT_UINT8 Validity = 10; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + AviationAttitudeMesg(void) : Mesg(Profile::MESG_AVIATION_ATTITUDE) + { + } + + AviationAttitudeMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Timestamp message was output + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Timestamp message was output + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Fractional part of timestamp, added to timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Fractional part of timestamp, added to timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of system_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSystemTime(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of system_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSystemTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns system_time field + // Units: ms + // Comment: System time associated with sample expressed in ms. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSystemTime(FIT_UINT8 index) const + { + return GetFieldUINT32Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set system_time field + // Units: ms + // Comment: System time associated with sample expressed in ms. + /////////////////////////////////////////////////////////////////////// + void SetSystemTime(FIT_UINT8 index, FIT_UINT32 systemTime) + { + SetFieldUINT32Value(1, systemTime, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of pitch + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumPitch(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pitch field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPitchValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pitch field + // Units: radians + // Comment: Range -PI/2 to +PI/2 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPitch(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pitch field + // Units: radians + // Comment: Range -PI/2 to +PI/2 + /////////////////////////////////////////////////////////////////////// + void SetPitch(FIT_UINT8 index, FIT_FLOAT32 pitch) + { + SetFieldFLOAT32Value(2, pitch, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of roll + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumRoll(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of roll field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRollValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns roll field + // Units: radians + // Comment: Range -PI to +PI + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRoll(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set roll field + // Units: radians + // Comment: Range -PI to +PI + /////////////////////////////////////////////////////////////////////// + void SetRoll(FIT_UINT8 index, FIT_FLOAT32 roll) + { + SetFieldFLOAT32Value(3, roll, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_lateral + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelLateral(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_lateral field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelLateralValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_lateral field + // Units: m/s^2 + // Comment: Range -78.4 to +78.4 (-8 Gs to 8 Gs) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAccelLateral(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_lateral field + // Units: m/s^2 + // Comment: Range -78.4 to +78.4 (-8 Gs to 8 Gs) + /////////////////////////////////////////////////////////////////////// + void SetAccelLateral(FIT_UINT8 index, FIT_FLOAT32 accelLateral) + { + SetFieldFLOAT32Value(4, accelLateral, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_normal + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelNormal(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_normal field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelNormalValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_normal field + // Units: m/s^2 + // Comment: Range -78.4 to +78.4 (-8 Gs to 8 Gs) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAccelNormal(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_normal field + // Units: m/s^2 + // Comment: Range -78.4 to +78.4 (-8 Gs to 8 Gs) + /////////////////////////////////////////////////////////////////////// + void SetAccelNormal(FIT_UINT8 index, FIT_FLOAT32 accelNormal) + { + SetFieldFLOAT32Value(5, accelNormal, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of turn_rate + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTurnRate(void) const + { + return GetFieldNumValues(6, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of turn_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTurnRateValid(FIT_UINT8 index) const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns turn_rate field + // Units: radians/second + // Comment: Range -8.727 to +8.727 (-500 degs/sec to +500 degs/sec) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTurnRate(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(6, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set turn_rate field + // Units: radians/second + // Comment: Range -8.727 to +8.727 (-500 degs/sec to +500 degs/sec) + /////////////////////////////////////////////////////////////////////// + void SetTurnRate(FIT_UINT8 index, FIT_FLOAT32 turnRate) + { + SetFieldFLOAT32Value(6, turnRate, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of stage + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumStage(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stage field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStageValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stage field + /////////////////////////////////////////////////////////////////////// + FIT_ATTITUDE_STAGE GetStage(FIT_UINT8 index) const + { + return GetFieldENUMValue(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stage field + /////////////////////////////////////////////////////////////////////// + void SetStage(FIT_UINT8 index, FIT_ATTITUDE_STAGE stage) + { + SetFieldENUMValue(7, stage, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of attitude_stage_complete + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAttitudeStageComplete(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of attitude_stage_complete field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAttitudeStageCompleteValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns attitude_stage_complete field + // Units: % + // Comment: The percent complete of the current attitude stage. Set to 0 for attitude stages 0, 1 and 2 and to 100 for attitude stage 3 by AHRS modules that do not support it. Range - 100 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAttitudeStageComplete(FIT_UINT8 index) const + { + return GetFieldUINT8Value(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set attitude_stage_complete field + // Units: % + // Comment: The percent complete of the current attitude stage. Set to 0 for attitude stages 0, 1 and 2 and to 100 for attitude stage 3 by AHRS modules that do not support it. Range - 100 + /////////////////////////////////////////////////////////////////////// + void SetAttitudeStageComplete(FIT_UINT8 index, FIT_UINT8 attitudeStageComplete) + { + SetFieldUINT8Value(8, attitudeStageComplete, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of track + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTrack(void) const + { + return GetFieldNumValues(9, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of track field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTrackValid(FIT_UINT8 index) const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns track field + // Units: radians + // Comment: Track Angle/Heading Range 0 - 2pi + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTrack(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(9, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set track field + // Units: radians + // Comment: Track Angle/Heading Range 0 - 2pi + /////////////////////////////////////////////////////////////////////// + void SetTrack(FIT_UINT8 index, FIT_FLOAT32 track) + { + SetFieldFLOAT32Value(9, track, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of validity + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumValidity(void) const + { + return GetFieldNumValues(10, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of validity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsValidityValid(FIT_UINT8 index) const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns validity field + /////////////////////////////////////////////////////////////////////// + FIT_ATTITUDE_VALIDITY GetValidity(FIT_UINT8 index) const + { + return GetFieldUINT16Value(10, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set validity field + /////////////////////////////////////////////////////////////////////// + void SetValidity(FIT_UINT8 index, FIT_ATTITUDE_VALIDITY validity) + { + SetFieldUINT16Value(10, validity, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_AVIATION_ATTITUDE_MESG_HPP) diff --git a/fit_aviation_attitude_mesg_listener.hpp b/fit_aviation_attitude_mesg_listener.hpp new file mode 100644 index 0000000..c76aed8 --- /dev/null +++ b/fit_aviation_attitude_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_AVIATION_ATTITUDE_MESG_LISTENER_HPP) +#define FIT_AVIATION_ATTITUDE_MESG_LISTENER_HPP + +#include "fit_aviation_attitude_mesg.hpp" + +namespace fit +{ + +class AviationAttitudeMesgListener +{ +public: + virtual ~AviationAttitudeMesgListener() {} + virtual void OnMesg(AviationAttitudeMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_AVIATION_ATTITUDE_MESG_LISTENER_HPP) diff --git a/fit_barometer_data_mesg.hpp b/fit_barometer_data_mesg.hpp new file mode 100644 index 0000000..1fc8ae0 --- /dev/null +++ b/fit_barometer_data_mesg.hpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BAROMETER_DATA_MESG_HPP) +#define FIT_BAROMETER_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class BarometerDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SampleTimeOffset = 1; + static const FIT_UINT8 BaroPres = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + BarometerDataMesg(void) : Mesg(Profile::MESG_BAROMETER_DATA) + { + } + + BarometerDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of sample_time_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSampleTimeOffset(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sample_time_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSampleTimeOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the barometer sample with the corrosponding index was taken. The samples may span across seconds. Array size must match the number of samples in baro_cal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSampleTimeOffset(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the barometer sample with the corrosponding index was taken. The samples may span across seconds. Array size must match the number of samples in baro_cal + /////////////////////////////////////////////////////////////////////// + void SetSampleTimeOffset(FIT_UINT8 index, FIT_UINT16 sampleTimeOffset) + { + SetFieldUINT16Value(1, sampleTimeOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of baro_pres + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumBaroPres(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of baro_pres field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBaroPresValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns baro_pres field + // Units: Pa + // Comment: These are the raw ADC reading. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetBaroPres(FIT_UINT8 index) const + { + return GetFieldUINT32Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set baro_pres field + // Units: Pa + // Comment: These are the raw ADC reading. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetBaroPres(FIT_UINT8 index, FIT_UINT32 baroPres) + { + SetFieldUINT32Value(2, baroPres, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_BAROMETER_DATA_MESG_HPP) diff --git a/fit_barometer_data_mesg_listener.hpp b/fit_barometer_data_mesg_listener.hpp new file mode 100644 index 0000000..d3c45fb --- /dev/null +++ b/fit_barometer_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BAROMETER_DATA_MESG_LISTENER_HPP) +#define FIT_BAROMETER_DATA_MESG_LISTENER_HPP + +#include "fit_barometer_data_mesg.hpp" + +namespace fit +{ + +class BarometerDataMesgListener +{ +public: + virtual ~BarometerDataMesgListener() {} + virtual void OnMesg(BarometerDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_BAROMETER_DATA_MESG_LISTENER_HPP) diff --git a/fit_beat_intervals_mesg.hpp b/fit_beat_intervals_mesg.hpp new file mode 100644 index 0000000..8144ce2 --- /dev/null +++ b/fit_beat_intervals_mesg.hpp @@ -0,0 +1,154 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BEAT_INTERVALS_MESG_HPP) +#define FIT_BEAT_INTERVALS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class BeatIntervalsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 Time = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + BeatIntervalsMesg(void) : Mesg(Profile::MESG_BEAT_INTERVALS) + { + } + + BeatIntervalsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Milliseconds past date_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Milliseconds past date_time + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTime(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time field + // Units: ms + // Comment: Array of millisecond times between beats + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTime(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time field + // Units: ms + // Comment: Array of millisecond times between beats + /////////////////////////////////////////////////////////////////////// + void SetTime(FIT_UINT8 index, FIT_UINT16 time) + { + SetFieldUINT16Value(1, time, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_BEAT_INTERVALS_MESG_HPP) diff --git a/fit_beat_intervals_mesg_listener.hpp b/fit_beat_intervals_mesg_listener.hpp new file mode 100644 index 0000000..7820251 --- /dev/null +++ b/fit_beat_intervals_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BEAT_INTERVALS_MESG_LISTENER_HPP) +#define FIT_BEAT_INTERVALS_MESG_LISTENER_HPP + +#include "fit_beat_intervals_mesg.hpp" + +namespace fit +{ + +class BeatIntervalsMesgListener +{ +public: + virtual ~BeatIntervalsMesgListener() {} + virtual void OnMesg(BeatIntervalsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_BEAT_INTERVALS_MESG_LISTENER_HPP) diff --git a/fit_bike_profile_mesg.hpp b/fit_bike_profile_mesg.hpp new file mode 100644 index 0000000..7fffa40 --- /dev/null +++ b/fit_bike_profile_mesg.hpp @@ -0,0 +1,1104 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BIKE_PROFILE_MESG_HPP) +#define FIT_BIKE_PROFILE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class BikeProfileMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Name = 0; + static const FIT_UINT8 Sport = 1; + static const FIT_UINT8 SubSport = 2; + static const FIT_UINT8 Odometer = 3; + static const FIT_UINT8 BikeSpdAntId = 4; + static const FIT_UINT8 BikeCadAntId = 5; + static const FIT_UINT8 BikeSpdcadAntId = 6; + static const FIT_UINT8 BikePowerAntId = 7; + static const FIT_UINT8 CustomWheelsize = 8; + static const FIT_UINT8 AutoWheelsize = 9; + static const FIT_UINT8 BikeWeight = 10; + static const FIT_UINT8 PowerCalFactor = 11; + static const FIT_UINT8 AutoWheelCal = 12; + static const FIT_UINT8 AutoPowerZero = 13; + static const FIT_UINT8 Id = 14; + static const FIT_UINT8 SpdEnabled = 15; + static const FIT_UINT8 CadEnabled = 16; + static const FIT_UINT8 SpdcadEnabled = 17; + static const FIT_UINT8 PowerEnabled = 18; + static const FIT_UINT8 CrankLength = 19; + static const FIT_UINT8 Enabled = 20; + static const FIT_UINT8 BikeSpdAntIdTransType = 21; + static const FIT_UINT8 BikeCadAntIdTransType = 22; + static const FIT_UINT8 BikeSpdcadAntIdTransType = 23; + static const FIT_UINT8 BikePowerAntIdTransType = 24; + static const FIT_UINT8 OdometerRollover = 37; + static const FIT_UINT8 FrontGearNum = 38; + static const FIT_UINT8 FrontGear = 39; + static const FIT_UINT8 RearGearNum = 40; + static const FIT_UINT8 RearGear = 41; + static const FIT_UINT8 ShimanoDi2Enabled = 44; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + BikeProfileMesg(void) : Mesg(Profile::MESG_BIKE_PROFILE) + { + } + + BikeProfileMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(0, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(1, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(2, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of odometer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOdometerValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns odometer field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetOdometer(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set odometer field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetOdometer(FIT_FLOAT32 odometer) + { + SetFieldFLOAT32Value(3, odometer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_spd_ant_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeSpdAntIdValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_spd_ant_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetBikeSpdAntId(void) const + { + return GetFieldUINT16ZValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_spd_ant_id field + /////////////////////////////////////////////////////////////////////// + void SetBikeSpdAntId(FIT_UINT16Z bikeSpdAntId) + { + SetFieldUINT16ZValue(4, bikeSpdAntId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_cad_ant_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeCadAntIdValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_cad_ant_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetBikeCadAntId(void) const + { + return GetFieldUINT16ZValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_cad_ant_id field + /////////////////////////////////////////////////////////////////////// + void SetBikeCadAntId(FIT_UINT16Z bikeCadAntId) + { + SetFieldUINT16ZValue(5, bikeCadAntId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_spdcad_ant_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeSpdcadAntIdValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_spdcad_ant_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetBikeSpdcadAntId(void) const + { + return GetFieldUINT16ZValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_spdcad_ant_id field + /////////////////////////////////////////////////////////////////////// + void SetBikeSpdcadAntId(FIT_UINT16Z bikeSpdcadAntId) + { + SetFieldUINT16ZValue(6, bikeSpdcadAntId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_power_ant_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikePowerAntIdValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_power_ant_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetBikePowerAntId(void) const + { + return GetFieldUINT16ZValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_power_ant_id field + /////////////////////////////////////////////////////////////////////// + void SetBikePowerAntId(FIT_UINT16Z bikePowerAntId) + { + SetFieldUINT16ZValue(7, bikePowerAntId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_wheelsize field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomWheelsizeValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns custom_wheelsize field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCustomWheelsize(void) const + { + return GetFieldFLOAT32Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_wheelsize field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetCustomWheelsize(FIT_FLOAT32 customWheelsize) + { + SetFieldFLOAT32Value(8, customWheelsize, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_wheelsize field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoWheelsizeValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns auto_wheelsize field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAutoWheelsize(void) const + { + return GetFieldFLOAT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_wheelsize field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAutoWheelsize(FIT_FLOAT32 autoWheelsize) + { + SetFieldFLOAT32Value(9, autoWheelsize, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_weight field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeWeightValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBikeWeight(void) const + { + return GetFieldFLOAT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetBikeWeight(FIT_FLOAT32 bikeWeight) + { + SetFieldFLOAT32Value(10, bikeWeight, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power_cal_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerCalFactorValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns power_cal_factor field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPowerCalFactor(void) const + { + return GetFieldFLOAT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set power_cal_factor field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetPowerCalFactor(FIT_FLOAT32 powerCalFactor) + { + SetFieldFLOAT32Value(11, powerCalFactor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_wheel_cal field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoWheelCalValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns auto_wheel_cal field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetAutoWheelCal(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_wheel_cal field + /////////////////////////////////////////////////////////////////////// + void SetAutoWheelCal(FIT_BOOL autoWheelCal) + { + SetFieldENUMValue(12, autoWheelCal, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_power_zero field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoPowerZeroValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns auto_power_zero field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetAutoPowerZero(void) const + { + return GetFieldENUMValue(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_power_zero field + /////////////////////////////////////////////////////////////////////// + void SetAutoPowerZero(FIT_BOOL autoPowerZero) + { + SetFieldENUMValue(13, autoPowerZero, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIdValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetId(void) const + { + return GetFieldUINT8Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set id field + /////////////////////////////////////////////////////////////////////// + void SetId(FIT_UINT8 id) + { + SetFieldUINT8Value(14, id, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of spd_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpdEnabledValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns spd_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetSpdEnabled(void) const + { + return GetFieldENUMValue(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set spd_enabled field + /////////////////////////////////////////////////////////////////////// + void SetSpdEnabled(FIT_BOOL spdEnabled) + { + SetFieldENUMValue(15, spdEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cad_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCadEnabledValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cad_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetCadEnabled(void) const + { + return GetFieldENUMValue(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cad_enabled field + /////////////////////////////////////////////////////////////////////// + void SetCadEnabled(FIT_BOOL cadEnabled) + { + SetFieldENUMValue(16, cadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of spdcad_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpdcadEnabledValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns spdcad_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetSpdcadEnabled(void) const + { + return GetFieldENUMValue(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set spdcad_enabled field + /////////////////////////////////////////////////////////////////////// + void SetSpdcadEnabled(FIT_BOOL spdcadEnabled) + { + SetFieldENUMValue(17, spdcadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerEnabledValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns power_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetPowerEnabled(void) const + { + return GetFieldENUMValue(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set power_enabled field + /////////////////////////////////////////////////////////////////////// + void SetPowerEnabled(FIT_BOOL powerEnabled) + { + SetFieldENUMValue(18, powerEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of crank_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCrankLengthValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns crank_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCrankLength(void) const + { + return GetFieldFLOAT32Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set crank_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetCrankLength(FIT_FLOAT32 crankLength) + { + SetFieldFLOAT32Value(19, crankLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(20, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_spd_ant_id_trans_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeSpdAntIdTransTypeValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_spd_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetBikeSpdAntIdTransType(void) const + { + return GetFieldUINT8ZValue(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_spd_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + void SetBikeSpdAntIdTransType(FIT_UINT8Z bikeSpdAntIdTransType) + { + SetFieldUINT8ZValue(21, bikeSpdAntIdTransType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_cad_ant_id_trans_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeCadAntIdTransTypeValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_cad_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetBikeCadAntIdTransType(void) const + { + return GetFieldUINT8ZValue(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_cad_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + void SetBikeCadAntIdTransType(FIT_UINT8Z bikeCadAntIdTransType) + { + SetFieldUINT8ZValue(22, bikeCadAntIdTransType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_spdcad_ant_id_trans_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikeSpdcadAntIdTransTypeValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_spdcad_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetBikeSpdcadAntIdTransType(void) const + { + return GetFieldUINT8ZValue(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_spdcad_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + void SetBikeSpdcadAntIdTransType(FIT_UINT8Z bikeSpdcadAntIdTransType) + { + SetFieldUINT8ZValue(23, bikeSpdcadAntIdTransType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bike_power_ant_id_trans_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBikePowerAntIdTransTypeValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bike_power_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetBikePowerAntIdTransType(void) const + { + return GetFieldUINT8ZValue(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bike_power_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + void SetBikePowerAntIdTransType(FIT_UINT8Z bikePowerAntIdTransType) + { + SetFieldUINT8ZValue(24, bikePowerAntIdTransType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of odometer_rollover field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOdometerRolloverValid() const + { + const Field* field = GetField(37); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns odometer_rollover field + // Comment: Rollover counter that can be used to extend the odometer + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetOdometerRollover(void) const + { + return GetFieldUINT8Value(37, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set odometer_rollover field + // Comment: Rollover counter that can be used to extend the odometer + /////////////////////////////////////////////////////////////////////// + void SetOdometerRollover(FIT_UINT8 odometerRollover) + { + SetFieldUINT8Value(37, odometerRollover, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of front_gear_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFrontGearNumValid() const + { + const Field* field = GetField(38); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns front_gear_num field + // Comment: Number of front gears + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetFrontGearNum(void) const + { + return GetFieldUINT8ZValue(38, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set front_gear_num field + // Comment: Number of front gears + /////////////////////////////////////////////////////////////////////// + void SetFrontGearNum(FIT_UINT8Z frontGearNum) + { + SetFieldUINT8ZValue(38, frontGearNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of front_gear + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumFrontGear(void) const + { + return GetFieldNumValues(39, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of front_gear field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFrontGearValid(FIT_UINT8 index) const + { + const Field* field = GetField(39); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns front_gear field + // Comment: Number of teeth on each gear 0 is innermost + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetFrontGear(FIT_UINT8 index) const + { + return GetFieldUINT8ZValue(39, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set front_gear field + // Comment: Number of teeth on each gear 0 is innermost + /////////////////////////////////////////////////////////////////////// + void SetFrontGear(FIT_UINT8 index, FIT_UINT8Z frontGear) + { + SetFieldUINT8ZValue(39, frontGear, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rear_gear_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRearGearNumValid() const + { + const Field* field = GetField(40); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rear_gear_num field + // Comment: Number of rear gears + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetRearGearNum(void) const + { + return GetFieldUINT8ZValue(40, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rear_gear_num field + // Comment: Number of rear gears + /////////////////////////////////////////////////////////////////////// + void SetRearGearNum(FIT_UINT8Z rearGearNum) + { + SetFieldUINT8ZValue(40, rearGearNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of rear_gear + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumRearGear(void) const + { + return GetFieldNumValues(41, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rear_gear field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRearGearValid(FIT_UINT8 index) const + { + const Field* field = GetField(41); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rear_gear field + // Comment: Number of teeth on each gear 0 is innermost + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetRearGear(FIT_UINT8 index) const + { + return GetFieldUINT8ZValue(41, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rear_gear field + // Comment: Number of teeth on each gear 0 is innermost + /////////////////////////////////////////////////////////////////////// + void SetRearGear(FIT_UINT8 index, FIT_UINT8Z rearGear) + { + SetFieldUINT8ZValue(41, rearGear, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of shimano_di2_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsShimanoDi2EnabledValid() const + { + const Field* field = GetField(44); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns shimano_di2_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetShimanoDi2Enabled(void) const + { + return GetFieldENUMValue(44, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set shimano_di2_enabled field + /////////////////////////////////////////////////////////////////////// + void SetShimanoDi2Enabled(FIT_BOOL shimanoDi2Enabled) + { + SetFieldENUMValue(44, shimanoDi2Enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_BIKE_PROFILE_MESG_HPP) diff --git a/fit_bike_profile_mesg_listener.hpp b/fit_bike_profile_mesg_listener.hpp new file mode 100644 index 0000000..7ba627f --- /dev/null +++ b/fit_bike_profile_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BIKE_PROFILE_MESG_LISTENER_HPP) +#define FIT_BIKE_PROFILE_MESG_LISTENER_HPP + +#include "fit_bike_profile_mesg.hpp" + +namespace fit +{ + +class BikeProfileMesgListener +{ +public: + virtual ~BikeProfileMesgListener() {} + virtual void OnMesg(BikeProfileMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_BIKE_PROFILE_MESG_LISTENER_HPP) diff --git a/fit_blood_pressure_mesg.hpp b/fit_blood_pressure_mesg.hpp new file mode 100644 index 0000000..02f77e6 --- /dev/null +++ b/fit_blood_pressure_mesg.hpp @@ -0,0 +1,412 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BLOOD_PRESSURE_MESG_HPP) +#define FIT_BLOOD_PRESSURE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class BloodPressureMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 SystolicPressure = 0; + static const FIT_UINT8 DiastolicPressure = 1; + static const FIT_UINT8 MeanArterialPressure = 2; + static const FIT_UINT8 Map3SampleMean = 3; + static const FIT_UINT8 MapMorningValues = 4; + static const FIT_UINT8 MapEveningValues = 5; + static const FIT_UINT8 HeartRate = 6; + static const FIT_UINT8 HeartRateType = 7; + static const FIT_UINT8 Status = 8; + static const FIT_UINT8 UserProfileIndex = 9; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + BloodPressureMesg(void) : Mesg(Profile::MESG_BLOOD_PRESSURE) + { + } + + BloodPressureMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of systolic_pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSystolicPressureValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns systolic_pressure field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSystolicPressure(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set systolic_pressure field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + void SetSystolicPressure(FIT_UINT16 systolicPressure) + { + SetFieldUINT16Value(0, systolicPressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of diastolic_pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiastolicPressureValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns diastolic_pressure field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetDiastolicPressure(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set diastolic_pressure field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + void SetDiastolicPressure(FIT_UINT16 diastolicPressure) + { + SetFieldUINT16Value(1, diastolicPressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mean_arterial_pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMeanArterialPressureValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mean_arterial_pressure field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMeanArterialPressure(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mean_arterial_pressure field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + void SetMeanArterialPressure(FIT_UINT16 meanArterialPressure) + { + SetFieldUINT16Value(2, meanArterialPressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of map_3_sample_mean field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMap3SampleMeanValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns map_3_sample_mean field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMap3SampleMean(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set map_3_sample_mean field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + void SetMap3SampleMean(FIT_UINT16 map3SampleMean) + { + SetFieldUINT16Value(3, map3SampleMean, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of map_morning_values field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMapMorningValuesValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns map_morning_values field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMapMorningValues(void) const + { + return GetFieldUINT16Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set map_morning_values field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + void SetMapMorningValues(FIT_UINT16 mapMorningValues) + { + SetFieldUINT16Value(4, mapMorningValues, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of map_evening_values field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMapEveningValuesValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns map_evening_values field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMapEveningValues(void) const + { + return GetFieldUINT16Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set map_evening_values field + // Units: mmHg + /////////////////////////////////////////////////////////////////////// + void SetMapEveningValues(FIT_UINT16 mapEveningValues) + { + SetFieldUINT16Value(5, mapEveningValues, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHeartRate(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHeartRate(FIT_UINT8 heartRate) + { + SetFieldUINT8Value(6, heartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateTypeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate_type field + /////////////////////////////////////////////////////////////////////// + FIT_HR_TYPE GetHeartRateType(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate_type field + /////////////////////////////////////////////////////////////////////// + void SetHeartRateType(FIT_HR_TYPE heartRateType) + { + SetFieldENUMValue(7, heartRateType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStatusValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns status field + /////////////////////////////////////////////////////////////////////// + FIT_BP_STATUS GetStatus(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set status field + /////////////////////////////////////////////////////////////////////// + void SetStatus(FIT_BP_STATUS status) + { + SetFieldENUMValue(8, status, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of user_profile_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUserProfileIndexValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns user_profile_index field + // Comment: Associates this blood pressure message to a user. This corresponds to the index of the user profile message in the blood pressure file. + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetUserProfileIndex(void) const + { + return GetFieldUINT16Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set user_profile_index field + // Comment: Associates this blood pressure message to a user. This corresponds to the index of the user profile message in the blood pressure file. + /////////////////////////////////////////////////////////////////////// + void SetUserProfileIndex(FIT_MESSAGE_INDEX userProfileIndex) + { + SetFieldUINT16Value(9, userProfileIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_BLOOD_PRESSURE_MESG_HPP) diff --git a/fit_blood_pressure_mesg_listener.hpp b/fit_blood_pressure_mesg_listener.hpp new file mode 100644 index 0000000..a696b54 --- /dev/null +++ b/fit_blood_pressure_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BLOOD_PRESSURE_MESG_LISTENER_HPP) +#define FIT_BLOOD_PRESSURE_MESG_LISTENER_HPP + +#include "fit_blood_pressure_mesg.hpp" + +namespace fit +{ + +class BloodPressureMesgListener +{ +public: + virtual ~BloodPressureMesgListener() {} + virtual void OnMesg(BloodPressureMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_BLOOD_PRESSURE_MESG_LISTENER_HPP) diff --git a/fit_buffer_encode.cpp b/fit_buffer_encode.cpp new file mode 100644 index 0000000..4a07a96 --- /dev/null +++ b/fit_buffer_encode.cpp @@ -0,0 +1,114 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_buffer_encode.hpp" +#include "fit_crc.hpp" + +namespace fit +{ + +BufferEncode::BufferEncode(void) +{ + this->Open(); +} + +void BufferEncode::Open() +{ + stringWriter.str(std::string("")); + stringWriter.clear(); + dataSize = 0; + + for (FIT_UINT8 i = 0; i < FIT_MAX_LOCAL_MESGS; ++i) + { + lastMesgDefinition[i].SetNum(FIT_MESG_NUM_INVALID); + lastMesgDefinition[i].SetLocalNum(i); + lastMesgDefinition[i].ClearFields(); + } +} + +void BufferEncode::Write(const MesgDefinition& mesgDef) +{ + dataSize += mesgDef.Write(stringWriter); + lastMesgDefinition[mesgDef.GetLocalNum()] = mesgDef; +} + +void BufferEncode::Write(const Mesg& mesg) +{ + MesgDefinition mesgDefinition(mesg); + + if (!lastMesgDefinition[mesg.GetLocalNum()].Supports(mesgDefinition)) + Write(mesgDefinition); + + dataSize += mesg.Write(stringWriter, &(lastMesgDefinition[mesg.GetLocalNum()])); +} + +void BufferEncode::Write(const std::vector& mesgs) +{ + for (std::vector::size_type i = 0; i < mesgs.size(); i++) + Write(mesgs[i]); +} + +std::string BufferEncode::Close(void) +{ + FIT_FILE_HDR file_header; + + // Get the data. + std::string dataString = stringWriter.str(); + + // Write the header. + stringWriter.str(std::string("")); + stringWriter.clear(); + file_header.header_size = FIT_FILE_HDR_SIZE; + file_header.profile_version = FIT_PROFILE_VERSION; + file_header.protocol_version = FIT_PROTOCOL_VERSION; + memcpy((FIT_UINT8 *)&file_header.data_type, ".FIT", 4); + file_header.data_size = dataSize; + file_header.crc = CRC::Calc16(&file_header, FIT_STRUCT_OFFSET(crc, FIT_FILE_HDR)); + stringWriter.write((const char *)&file_header, FIT_FILE_HDR_SIZE); + + std::string headerString = stringWriter.str(); + + // Write the CRC. + stringWriter.str(std::string("")); + stringWriter.clear(); + + FIT_UINT16 crc = 0; + + for (std::string::size_type i = 0; i < headerString.size(); i++) + crc = CRC::Get16(crc, (int) headerString[i]); + + for (std::string::size_type i = 0; i < dataString.size(); i++) + crc = CRC::Get16(crc, (int) dataString[i]); + + stringWriter.put(crc & 0xFF); + stringWriter.put((char)(crc >> 8)); + + std::string crcString = stringWriter.str(); + + // Discard the output stream and re-initialize. + Open(); + + // Put the result together. + return (headerString + dataString + crcString); +} + +void BufferEncode::OnMesg(Mesg &mesg) +{ + Write(mesg); +} + +void BufferEncode::OnMesgDefinition(MesgDefinition& mesgDef) +{ + Write(mesgDef); +} + +} // namespace fit diff --git a/fit_buffer_encode.hpp b/fit_buffer_encode.hpp new file mode 100644 index 0000000..9418de6 --- /dev/null +++ b/fit_buffer_encode.hpp @@ -0,0 +1,48 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BUFFER_ENCODE_HPP) +#define FIT_BUFFER_ENCODE_HPP + +#include +#include +#include +#include "fit.hpp" +#include "fit_mesg.hpp" +#include "fit_mesg_definition.hpp" +#include "fit_mesg_definition_listener.hpp" +#include "fit_mesg_listener.hpp" + +namespace fit +{ + +class BufferEncode : public MesgListener, public MesgDefinitionListener +{ + public: + BufferEncode(void); + void Open(); + void Write(const MesgDefinition& mesgDef); + void Write(const Mesg& mesg); + void Write(const std::vector& mesgs); + std::string Close(void); + void OnMesg(Mesg& mesg); + void OnMesgDefinition(MesgDefinition& mesgDef); + + private: + std::stringstream stringWriter; + FIT_UINT32 dataSize; + MesgDefinition lastMesgDefinition[FIT_MAX_LOCAL_MESGS]; +}; + +} // namespace fit + +#endif // defined(FIT_BUFFER_ENCODE_HPP) diff --git a/fit_buffered_mesg_broadcaster.cpp b/fit_buffered_mesg_broadcaster.cpp new file mode 100644 index 0000000..490fa9c --- /dev/null +++ b/fit_buffered_mesg_broadcaster.cpp @@ -0,0 +1,52 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + + +#include "fit_buffered_mesg_broadcaster.hpp" + + +namespace fit +{ + +void BufferedMesgBroadcaster::RegisterMesgBroadcastPlugin(MesgBroadcastPlugin* plugin) +{ + plugins.push_back(plugin); +} + +void BufferedMesgBroadcaster::OnMesg(Mesg& mesg) +{ + mesgs.push_back(mesg); + + // Pass the message to each plugin. This gives the + // plugin a chance to peek the incoming messages + for(size_t i = 0; i < plugins.size(); i++) + { + if(plugins[i]) + plugins[i]->OnIncomingMesg(mesg); + } +} + +void BufferedMesgBroadcaster::Broadcast(void) +{ + for(size_t i = 0; i < plugins.size(); i++) + { + if(plugins[i]) + plugins[i]->OnBroadcast(mesgs); + } + + for(size_t j = 0; j < mesgs.size(); j++) + { + MesgBroadcaster::OnMesg(mesgs[j]); + } +} + +} // namespace fit diff --git a/fit_buffered_mesg_broadcaster.hpp b/fit_buffered_mesg_broadcaster.hpp new file mode 100644 index 0000000..98db688 --- /dev/null +++ b/fit_buffered_mesg_broadcaster.hpp @@ -0,0 +1,39 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + + +#if !defined(FIT_BUFFERED_MESG_BROADCASTER_HPP) +#define FIT_BUFFERED_MESG_BROADCASTER_HPP + +#include "fit_mesg_broadcaster.hpp" +#include "fit_mesg_broadcast_plugin.hpp" +#include + + +namespace fit +{ + +class BufferedMesgBroadcaster : public MesgBroadcaster +{ + public: + void RegisterMesgBroadcastPlugin(MesgBroadcastPlugin* plugin); + void OnMesg(Mesg& mesg); + void Broadcast(void); + + private: + std::vector mesgs; + std::vector plugins; +}; + +} // namespace fit + +#endif // !defined(FIT_BUFFERED_MESG_BROADCASTER_HPP) diff --git a/fit_buffered_record_mesg.hpp b/fit_buffered_record_mesg.hpp new file mode 100644 index 0000000..846e113 --- /dev/null +++ b/fit_buffered_record_mesg.hpp @@ -0,0 +1,27 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BUFFERED_RECORD_MESG_HPP) +#define FIT_BUFFERED_RECORD_MESG_HPP + +#include "fit_record_mesg.hpp" + +namespace fit +{ + +class BufferedRecordMesg : public RecordMesg +{ +}; + +} // namespace fit + +#endif // !defined(FIT_BUFFERED_RECORD_MESG_HPP) diff --git a/fit_buffered_record_mesg_broadcaster.cpp b/fit_buffered_record_mesg_broadcaster.cpp new file mode 100644 index 0000000..0aec8f3 --- /dev/null +++ b/fit_buffered_record_mesg_broadcaster.cpp @@ -0,0 +1,45 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_buffered_record_mesg_broadcaster.hpp" +#include + +namespace fit +{ + +BufferedRecordMesgBroadcaster::BufferedRecordMesgBroadcaster(void) +{ +} + +void BufferedRecordMesgBroadcaster::AddListener(BufferedRecordMesgListener& mesgListener) +{ + listeners.push_back(&mesgListener); +} + +void BufferedRecordMesgBroadcaster::RemoveListener(BufferedRecordMesgListener& mesgListener) +{ + std::vector::iterator it = std::find(listeners.begin(), listeners.end(), &mesgListener); + if (listeners.end() != it) + listeners.erase(it); +} + +void BufferedRecordMesgBroadcaster::OnMesg(RecordMesg& mesg) +{ + bufferedRecordMesg.SetFields(mesg); + + for (int i = 0; i < (int)listeners.size(); i++) + { + listeners[i]->OnMesg(bufferedRecordMesg); + } +} + +} // namespace fit diff --git a/fit_buffered_record_mesg_broadcaster.hpp b/fit_buffered_record_mesg_broadcaster.hpp new file mode 100644 index 0000000..6653b1c --- /dev/null +++ b/fit_buffered_record_mesg_broadcaster.hpp @@ -0,0 +1,39 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BUFFERED_RECORD_MESG_BROADCASTER_HPP) +#define FIT_BUFFERED_RECORD_MESG_BROADCASTER_HPP + +#include +#include "fit_buffered_record_mesg_listener.hpp" +#include "fit_buffered_record_mesg.hpp" +#include "fit_record_mesg_listener.hpp" + +namespace fit +{ + +class BufferedRecordMesgBroadcaster : public RecordMesgListener +{ + public: + BufferedRecordMesgBroadcaster(void); + void AddListener(BufferedRecordMesgListener& mesgListener); + void RemoveListener(BufferedRecordMesgListener& mesgListener); + void OnMesg(RecordMesg& mesg); + + private: + BufferedRecordMesg bufferedRecordMesg; + std::vector listeners; +}; + +} // namespace fit + +#endif // !defined(FIT_BUFFERED_RECORD_MESG_BROADCASTER_HPP) diff --git a/fit_buffered_record_mesg_listener.hpp b/fit_buffered_record_mesg_listener.hpp new file mode 100644 index 0000000..5ef894b --- /dev/null +++ b/fit_buffered_record_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_BUFFERED_RECORD_MESG_LISTENER_HPP) +#define FIT_BUFFERED_RECORD_MESG_LISTENER_HPP + +#include "fit_buffered_record_mesg.hpp" + +namespace fit +{ + +class BufferedRecordMesgListener +{ + public: + virtual ~BufferedRecordMesgListener() {} + virtual void OnMesg(BufferedRecordMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_BUFFERED_RECORD_MESG_LISTENER_HPP) diff --git a/fit_cadence_zone_mesg.hpp b/fit_cadence_zone_mesg.hpp new file mode 100644 index 0000000..213ee8c --- /dev/null +++ b/fit_cadence_zone_mesg.hpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CADENCE_ZONE_MESG_HPP) +#define FIT_CADENCE_ZONE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class CadenceZoneMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 HighValue = 0; + static const FIT_UINT8 Name = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + CadenceZoneMesg(void) : Mesg(Profile::MESG_CADENCE_ZONE) + { + } + + CadenceZoneMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of high_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHighValueValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns high_value field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHighValue(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set high_value field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetHighValue(FIT_UINT8 highValue) + { + SetFieldUINT8Value(0, highValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(1, name, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CADENCE_ZONE_MESG_HPP) diff --git a/fit_cadence_zone_mesg_listener.hpp b/fit_cadence_zone_mesg_listener.hpp new file mode 100644 index 0000000..609c50a --- /dev/null +++ b/fit_cadence_zone_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CADENCE_ZONE_MESG_LISTENER_HPP) +#define FIT_CADENCE_ZONE_MESG_LISTENER_HPP + +#include "fit_cadence_zone_mesg.hpp" + +namespace fit +{ + +class CadenceZoneMesgListener +{ +public: + virtual ~CadenceZoneMesgListener() {} + virtual void OnMesg(CadenceZoneMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CADENCE_ZONE_MESG_LISTENER_HPP) diff --git a/fit_camera_event_mesg.hpp b/fit_camera_event_mesg.hpp new file mode 100644 index 0000000..cfff750 --- /dev/null +++ b/fit_camera_event_mesg.hpp @@ -0,0 +1,210 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CAMERA_EVENT_MESG_HPP) +#define FIT_CAMERA_EVENT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class CameraEventMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 CameraEventType = 1; + static const FIT_UINT8 CameraFileUuid = 2; + static const FIT_UINT8 CameraOrientation = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + CameraEventMesg(void) : Mesg(Profile::MESG_CAMERA_EVENT) + { + } + + CameraEventMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of camera_event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCameraEventTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns camera_event_type field + /////////////////////////////////////////////////////////////////////// + FIT_CAMERA_EVENT_TYPE GetCameraEventType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set camera_event_type field + /////////////////////////////////////////////////////////////////////// + void SetCameraEventType(FIT_CAMERA_EVENT_TYPE cameraEventType) + { + SetFieldENUMValue(1, cameraEventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of camera_file_uuid field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCameraFileUuidValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns camera_file_uuid field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetCameraFileUuid(void) const + { + return GetFieldSTRINGValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set camera_file_uuid field + /////////////////////////////////////////////////////////////////////// + void SetCameraFileUuid(FIT_WSTRING cameraFileUuid) + { + SetFieldSTRINGValue(2, cameraFileUuid, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of camera_orientation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCameraOrientationValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns camera_orientation field + /////////////////////////////////////////////////////////////////////// + FIT_CAMERA_ORIENTATION_TYPE GetCameraOrientation(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set camera_orientation field + /////////////////////////////////////////////////////////////////////// + void SetCameraOrientation(FIT_CAMERA_ORIENTATION_TYPE cameraOrientation) + { + SetFieldENUMValue(3, cameraOrientation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CAMERA_EVENT_MESG_HPP) diff --git a/fit_camera_event_mesg_listener.hpp b/fit_camera_event_mesg_listener.hpp new file mode 100644 index 0000000..f674720 --- /dev/null +++ b/fit_camera_event_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CAMERA_EVENT_MESG_LISTENER_HPP) +#define FIT_CAMERA_EVENT_MESG_LISTENER_HPP + +#include "fit_camera_event_mesg.hpp" + +namespace fit +{ + +class CameraEventMesgListener +{ +public: + virtual ~CameraEventMesgListener() {} + virtual void OnMesg(CameraEventMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CAMERA_EVENT_MESG_LISTENER_HPP) diff --git a/fit_capabilities_mesg.hpp b/fit_capabilities_mesg.hpp new file mode 100644 index 0000000..fa59b24 --- /dev/null +++ b/fit_capabilities_mesg.hpp @@ -0,0 +1,190 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CAPABILITIES_MESG_HPP) +#define FIT_CAPABILITIES_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class CapabilitiesMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Languages = 0; + static const FIT_UINT8 Sports = 1; + static const FIT_UINT8 WorkoutsSupported = 21; + static const FIT_UINT8 ConnectivitySupported = 23; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + CapabilitiesMesg(void) : Mesg(Profile::MESG_CAPABILITIES) + { + } + + CapabilitiesMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of languages + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLanguages(void) const + { + return GetFieldNumValues(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of languages field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLanguagesValid(FIT_UINT8 index) const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns languages field + // Comment: Use language_bits_x types where x is index of array. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetLanguages(FIT_UINT8 index) const + { + return GetFieldUINT8ZValue(0, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set languages field + // Comment: Use language_bits_x types where x is index of array. + /////////////////////////////////////////////////////////////////////// + void SetLanguages(FIT_UINT8 index, FIT_UINT8Z languages) + { + SetFieldUINT8ZValue(0, languages, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of sports + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSports(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sports field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportsValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sports field + // Comment: Use sport_bits_x types where x is index of array. + /////////////////////////////////////////////////////////////////////// + FIT_SPORT_BITS_0 GetSports(FIT_UINT8 index) const + { + return GetFieldUINT8ZValue(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sports field + // Comment: Use sport_bits_x types where x is index of array. + /////////////////////////////////////////////////////////////////////// + void SetSports(FIT_UINT8 index, FIT_SPORT_BITS_0 sports) + { + SetFieldUINT8ZValue(1, sports, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of workouts_supported field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWorkoutsSupportedValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns workouts_supported field + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_CAPABILITIES GetWorkoutsSupported(void) const + { + return GetFieldUINT32ZValue(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set workouts_supported field + /////////////////////////////////////////////////////////////////////// + void SetWorkoutsSupported(FIT_WORKOUT_CAPABILITIES workoutsSupported) + { + SetFieldUINT32ZValue(21, workoutsSupported, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of connectivity_supported field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConnectivitySupportedValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns connectivity_supported field + /////////////////////////////////////////////////////////////////////// + FIT_CONNECTIVITY_CAPABILITIES GetConnectivitySupported(void) const + { + return GetFieldUINT32ZValue(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set connectivity_supported field + /////////////////////////////////////////////////////////////////////// + void SetConnectivitySupported(FIT_CONNECTIVITY_CAPABILITIES connectivitySupported) + { + SetFieldUINT32ZValue(23, connectivitySupported, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CAPABILITIES_MESG_HPP) diff --git a/fit_capabilities_mesg_listener.hpp b/fit_capabilities_mesg_listener.hpp new file mode 100644 index 0000000..6180b88 --- /dev/null +++ b/fit_capabilities_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CAPABILITIES_MESG_LISTENER_HPP) +#define FIT_CAPABILITIES_MESG_LISTENER_HPP + +#include "fit_capabilities_mesg.hpp" + +namespace fit +{ + +class CapabilitiesMesgListener +{ +public: + virtual ~CapabilitiesMesgListener() {} + virtual void OnMesg(CapabilitiesMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CAPABILITIES_MESG_LISTENER_HPP) diff --git a/fit_chrono_shot_data_mesg.hpp b/fit_chrono_shot_data_mesg.hpp new file mode 100644 index 0000000..738af2c --- /dev/null +++ b/fit_chrono_shot_data_mesg.hpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CHRONO_SHOT_DATA_MESG_HPP) +#define FIT_CHRONO_SHOT_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ChronoShotDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ShotSpeed = 0; + static const FIT_UINT8 ShotNum = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ChronoShotDataMesg(void) : Mesg(Profile::MESG_CHRONO_SHOT_DATA) + { + } + + ChronoShotDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of shot_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsShotSpeedValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns shot_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetShotSpeed(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set shot_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetShotSpeed(FIT_FLOAT32 shotSpeed) + { + SetFieldFLOAT32Value(0, shotSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of shot_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsShotNumValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns shot_num field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetShotNum(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set shot_num field + /////////////////////////////////////////////////////////////////////// + void SetShotNum(FIT_UINT16 shotNum) + { + SetFieldUINT16Value(1, shotNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CHRONO_SHOT_DATA_MESG_HPP) diff --git a/fit_chrono_shot_data_mesg_listener.hpp b/fit_chrono_shot_data_mesg_listener.hpp new file mode 100644 index 0000000..28ce5e6 --- /dev/null +++ b/fit_chrono_shot_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CHRONO_SHOT_DATA_MESG_LISTENER_HPP) +#define FIT_CHRONO_SHOT_DATA_MESG_LISTENER_HPP + +#include "fit_chrono_shot_data_mesg.hpp" + +namespace fit +{ + +class ChronoShotDataMesgListener +{ +public: + virtual ~ChronoShotDataMesgListener() {} + virtual void OnMesg(ChronoShotDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CHRONO_SHOT_DATA_MESG_LISTENER_HPP) diff --git a/fit_chrono_shot_session_mesg.hpp b/fit_chrono_shot_session_mesg.hpp new file mode 100644 index 0000000..aa37024 --- /dev/null +++ b/fit_chrono_shot_session_mesg.hpp @@ -0,0 +1,308 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CHRONO_SHOT_SESSION_MESG_HPP) +#define FIT_CHRONO_SHOT_SESSION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ChronoShotSessionMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 MinSpeed = 0; + static const FIT_UINT8 MaxSpeed = 1; + static const FIT_UINT8 AvgSpeed = 2; + static const FIT_UINT8 ShotCount = 3; + static const FIT_UINT8 ProjectileType = 4; + static const FIT_UINT8 GrainWeight = 5; + static const FIT_UINT8 StandardDeviation = 6; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ChronoShotSessionMesg(void) : Mesg(Profile::MESG_CHRONO_SHOT_SESSION) + { + } + + ChronoShotSessionMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinSpeedValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinSpeed(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMinSpeed(FIT_FLOAT32 minSpeed) + { + SetFieldFLOAT32Value(0, minSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSpeedValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSpeed(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxSpeed(FIT_FLOAT32 maxSpeed) + { + SetFieldFLOAT32Value(1, maxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(2, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of shot_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsShotCountValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns shot_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetShotCount(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set shot_count field + /////////////////////////////////////////////////////////////////////// + void SetShotCount(FIT_UINT16 shotCount) + { + SetFieldUINT16Value(3, shotCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of projectile_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProjectileTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns projectile_type field + /////////////////////////////////////////////////////////////////////// + FIT_PROJECTILE_TYPE GetProjectileType(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set projectile_type field + /////////////////////////////////////////////////////////////////////// + void SetProjectileType(FIT_PROJECTILE_TYPE projectileType) + { + SetFieldENUMValue(4, projectileType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of grain_weight field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGrainWeightValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns grain_weight field + // Units: gr + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetGrainWeight(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set grain_weight field + // Units: gr + /////////////////////////////////////////////////////////////////////// + void SetGrainWeight(FIT_FLOAT32 grainWeight) + { + SetFieldFLOAT32Value(5, grainWeight, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of standard_deviation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStandardDeviationValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns standard_deviation field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStandardDeviation(void) const + { + return GetFieldFLOAT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set standard_deviation field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetStandardDeviation(FIT_FLOAT32 standardDeviation) + { + SetFieldFLOAT32Value(6, standardDeviation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CHRONO_SHOT_SESSION_MESG_HPP) diff --git a/fit_chrono_shot_session_mesg_listener.hpp b/fit_chrono_shot_session_mesg_listener.hpp new file mode 100644 index 0000000..7140d1f --- /dev/null +++ b/fit_chrono_shot_session_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CHRONO_SHOT_SESSION_MESG_LISTENER_HPP) +#define FIT_CHRONO_SHOT_SESSION_MESG_LISTENER_HPP + +#include "fit_chrono_shot_session_mesg.hpp" + +namespace fit +{ + +class ChronoShotSessionMesgListener +{ +public: + virtual ~ChronoShotSessionMesgListener() {} + virtual void OnMesg(ChronoShotSessionMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CHRONO_SHOT_SESSION_MESG_LISTENER_HPP) diff --git a/fit_climb_pro_mesg.hpp b/fit_climb_pro_mesg.hpp new file mode 100644 index 0000000..f5af27c --- /dev/null +++ b/fit_climb_pro_mesg.hpp @@ -0,0 +1,274 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CLIMB_PRO_MESG_HPP) +#define FIT_CLIMB_PRO_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ClimbProMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 PositionLat = 0; + static const FIT_UINT8 PositionLong = 1; + static const FIT_UINT8 ClimbProEvent = 2; + static const FIT_UINT8 ClimbNumber = 3; + static const FIT_UINT8 ClimbCategory = 4; + static const FIT_UINT8 CurrentDist = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ClimbProMesg(void) : Mesg(Profile::MESG_CLIMB_PRO) + { + } + + ClimbProMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLatValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLat(void) const + { + return GetFieldSINT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLat(FIT_SINT32 positionLat) + { + SetFieldSINT32Value(0, positionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLongValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLong(void) const + { + return GetFieldSINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLong(FIT_SINT32 positionLong) + { + SetFieldSINT32Value(1, positionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of climb_pro_event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClimbProEventValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns climb_pro_event field + /////////////////////////////////////////////////////////////////////// + FIT_CLIMB_PRO_EVENT GetClimbProEvent(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set climb_pro_event field + /////////////////////////////////////////////////////////////////////// + void SetClimbProEvent(FIT_CLIMB_PRO_EVENT climbProEvent) + { + SetFieldENUMValue(2, climbProEvent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of climb_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClimbNumberValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns climb_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetClimbNumber(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set climb_number field + /////////////////////////////////////////////////////////////////////// + void SetClimbNumber(FIT_UINT16 climbNumber) + { + SetFieldUINT16Value(3, climbNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of climb_category field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClimbCategoryValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns climb_category field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetClimbCategory(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set climb_category field + /////////////////////////////////////////////////////////////////////// + void SetClimbCategory(FIT_UINT8 climbCategory) + { + SetFieldUINT8Value(4, climbCategory, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of current_dist field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCurrentDistValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns current_dist field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCurrentDist(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set current_dist field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetCurrentDist(FIT_FLOAT32 currentDist) + { + SetFieldFLOAT32Value(5, currentDist, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CLIMB_PRO_MESG_HPP) diff --git a/fit_climb_pro_mesg_listener.hpp b/fit_climb_pro_mesg_listener.hpp new file mode 100644 index 0000000..b6a25ff --- /dev/null +++ b/fit_climb_pro_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CLIMB_PRO_MESG_LISTENER_HPP) +#define FIT_CLIMB_PRO_MESG_LISTENER_HPP + +#include "fit_climb_pro_mesg.hpp" + +namespace fit +{ + +class ClimbProMesgListener +{ +public: + virtual ~ClimbProMesgListener() {} + virtual void OnMesg(ClimbProMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CLIMB_PRO_MESG_LISTENER_HPP) diff --git a/fit_config.hpp b/fit_config.hpp new file mode 100644 index 0000000..5646a16 --- /dev/null +++ b/fit_config.hpp @@ -0,0 +1,27 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CONFIG_HPP) +#define FIT_CONFIG_HPP + + +#if defined(__cplusplus) + extern "C" { +#endif + +#define FIT_USE_STDINT_H // Define to use stdint.h types. By default size in bytes of integer types assumed to be char=1, short=2, long=4. + +#define FIT_WIDE_CHAR_SIZE 2 // Define the size of a wide character (1, 2 or 4 bytes). + // Character encoding also defined by size. 1: UTF-8 2: UTF-16 4: UTF-32 +//#define FIT_CPP_INCLUDE_C // Define to include C definitions in C++ header file. Allows C and C++ code to be compiled together. + +#if defined(__cplusplus) + } +#endif + +#endif // !defined(FIT_CONFIG_HPP) diff --git a/fit_connectivity_mesg.hpp b/fit_connectivity_mesg.hpp new file mode 100644 index 0000000..3c38c78 --- /dev/null +++ b/fit_connectivity_mesg.hpp @@ -0,0 +1,464 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CONNECTIVITY_MESG_HPP) +#define FIT_CONNECTIVITY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ConnectivityMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 BluetoothEnabled = 0; + static const FIT_UINT8 BluetoothLeEnabled = 1; + static const FIT_UINT8 AntEnabled = 2; + static const FIT_UINT8 Name = 3; + static const FIT_UINT8 LiveTrackingEnabled = 4; + static const FIT_UINT8 WeatherConditionsEnabled = 5; + static const FIT_UINT8 WeatherAlertsEnabled = 6; + static const FIT_UINT8 AutoActivityUploadEnabled = 7; + static const FIT_UINT8 CourseDownloadEnabled = 8; + static const FIT_UINT8 WorkoutDownloadEnabled = 9; + static const FIT_UINT8 GpsEphemerisDownloadEnabled = 10; + static const FIT_UINT8 IncidentDetectionEnabled = 11; + static const FIT_UINT8 GrouptrackEnabled = 12; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ConnectivityMesg(void) : Mesg(Profile::MESG_CONNECTIVITY) + { + } + + ConnectivityMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bluetooth_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBluetoothEnabledValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bluetooth_enabled field + // Comment: Use Bluetooth for connectivity features + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetBluetoothEnabled(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bluetooth_enabled field + // Comment: Use Bluetooth for connectivity features + /////////////////////////////////////////////////////////////////////// + void SetBluetoothEnabled(FIT_BOOL bluetoothEnabled) + { + SetFieldENUMValue(0, bluetoothEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bluetooth_le_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBluetoothLeEnabledValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bluetooth_le_enabled field + // Comment: Use Bluetooth Low Energy for connectivity features + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetBluetoothLeEnabled(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bluetooth_le_enabled field + // Comment: Use Bluetooth Low Energy for connectivity features + /////////////////////////////////////////////////////////////////////// + void SetBluetoothLeEnabled(FIT_BOOL bluetoothLeEnabled) + { + SetFieldENUMValue(1, bluetoothLeEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ant_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAntEnabledValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ant_enabled field + // Comment: Use ANT for connectivity features + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetAntEnabled(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ant_enabled field + // Comment: Use ANT for connectivity features + /////////////////////////////////////////////////////////////////////// + void SetAntEnabled(FIT_BOOL antEnabled) + { + SetFieldENUMValue(2, antEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(3, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of live_tracking_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLiveTrackingEnabledValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns live_tracking_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetLiveTrackingEnabled(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set live_tracking_enabled field + /////////////////////////////////////////////////////////////////////// + void SetLiveTrackingEnabled(FIT_BOOL liveTrackingEnabled) + { + SetFieldENUMValue(4, liveTrackingEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weather_conditions_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeatherConditionsEnabledValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weather_conditions_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetWeatherConditionsEnabled(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weather_conditions_enabled field + /////////////////////////////////////////////////////////////////////// + void SetWeatherConditionsEnabled(FIT_BOOL weatherConditionsEnabled) + { + SetFieldENUMValue(5, weatherConditionsEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weather_alerts_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeatherAlertsEnabledValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weather_alerts_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetWeatherAlertsEnabled(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weather_alerts_enabled field + /////////////////////////////////////////////////////////////////////// + void SetWeatherAlertsEnabled(FIT_BOOL weatherAlertsEnabled) + { + SetFieldENUMValue(6, weatherAlertsEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_activity_upload_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoActivityUploadEnabledValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns auto_activity_upload_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetAutoActivityUploadEnabled(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_activity_upload_enabled field + /////////////////////////////////////////////////////////////////////// + void SetAutoActivityUploadEnabled(FIT_BOOL autoActivityUploadEnabled) + { + SetFieldENUMValue(7, autoActivityUploadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of course_download_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCourseDownloadEnabledValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns course_download_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetCourseDownloadEnabled(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set course_download_enabled field + /////////////////////////////////////////////////////////////////////// + void SetCourseDownloadEnabled(FIT_BOOL courseDownloadEnabled) + { + SetFieldENUMValue(8, courseDownloadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of workout_download_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWorkoutDownloadEnabledValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns workout_download_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetWorkoutDownloadEnabled(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set workout_download_enabled field + /////////////////////////////////////////////////////////////////////// + void SetWorkoutDownloadEnabled(FIT_BOOL workoutDownloadEnabled) + { + SetFieldENUMValue(9, workoutDownloadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gps_ephemeris_download_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGpsEphemerisDownloadEnabledValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gps_ephemeris_download_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetGpsEphemerisDownloadEnabled(void) const + { + return GetFieldENUMValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gps_ephemeris_download_enabled field + /////////////////////////////////////////////////////////////////////// + void SetGpsEphemerisDownloadEnabled(FIT_BOOL gpsEphemerisDownloadEnabled) + { + SetFieldENUMValue(10, gpsEphemerisDownloadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of incident_detection_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIncidentDetectionEnabledValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns incident_detection_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetIncidentDetectionEnabled(void) const + { + return GetFieldENUMValue(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set incident_detection_enabled field + /////////////////////////////////////////////////////////////////////// + void SetIncidentDetectionEnabled(FIT_BOOL incidentDetectionEnabled) + { + SetFieldENUMValue(11, incidentDetectionEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of grouptrack_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGrouptrackEnabledValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns grouptrack_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetGrouptrackEnabled(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set grouptrack_enabled field + /////////////////////////////////////////////////////////////////////// + void SetGrouptrackEnabled(FIT_BOOL grouptrackEnabled) + { + SetFieldENUMValue(12, grouptrackEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_CONNECTIVITY_MESG_HPP) diff --git a/fit_connectivity_mesg_listener.hpp b/fit_connectivity_mesg_listener.hpp new file mode 100644 index 0000000..919da5a --- /dev/null +++ b/fit_connectivity_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CONNECTIVITY_MESG_LISTENER_HPP) +#define FIT_CONNECTIVITY_MESG_LISTENER_HPP + +#include "fit_connectivity_mesg.hpp" + +namespace fit +{ + +class ConnectivityMesgListener +{ +public: + virtual ~ConnectivityMesgListener() {} + virtual void OnMesg(ConnectivityMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_CONNECTIVITY_MESG_LISTENER_HPP) diff --git a/fit_course_mesg.hpp b/fit_course_mesg.hpp new file mode 100644 index 0000000..814d8c4 --- /dev/null +++ b/fit_course_mesg.hpp @@ -0,0 +1,170 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_COURSE_MESG_HPP) +#define FIT_COURSE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class CourseMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Sport = 4; + static const FIT_UINT8 Name = 5; + static const FIT_UINT8 Capabilities = 6; + static const FIT_UINT8 SubSport = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + CourseMesg(void) : Mesg(Profile::MESG_COURSE) + { + } + + CourseMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(4, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(5, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of capabilities field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCapabilitiesValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns capabilities field + /////////////////////////////////////////////////////////////////////// + FIT_COURSE_CAPABILITIES GetCapabilities(void) const + { + return GetFieldUINT32ZValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set capabilities field + /////////////////////////////////////////////////////////////////////// + void SetCapabilities(FIT_COURSE_CAPABILITIES capabilities) + { + SetFieldUINT32ZValue(6, capabilities, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(7, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_COURSE_MESG_HPP) diff --git a/fit_course_mesg_listener.hpp b/fit_course_mesg_listener.hpp new file mode 100644 index 0000000..c50cbbb --- /dev/null +++ b/fit_course_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_COURSE_MESG_LISTENER_HPP) +#define FIT_COURSE_MESG_LISTENER_HPP + +#include "fit_course_mesg.hpp" + +namespace fit +{ + +class CourseMesgListener +{ +public: + virtual ~CourseMesgListener() {} + virtual void OnMesg(CourseMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_COURSE_MESG_LISTENER_HPP) diff --git a/fit_course_point_mesg.hpp b/fit_course_point_mesg.hpp new file mode 100644 index 0000000..6564191 --- /dev/null +++ b/fit_course_point_mesg.hpp @@ -0,0 +1,304 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_COURSE_POINT_MESG_HPP) +#define FIT_COURSE_POINT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class CoursePointMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 1; + static const FIT_UINT8 PositionLat = 2; + static const FIT_UINT8 PositionLong = 3; + static const FIT_UINT8 Distance = 4; + static const FIT_UINT8 Type = 5; + static const FIT_UINT8 Name = 6; + static const FIT_UINT8 Favorite = 8; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + CoursePointMesg(void) : Mesg(Profile::MESG_COURSE_POINT) + { + } + + CoursePointMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(1, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLatValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLat(void) const + { + return GetFieldSINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLat(FIT_SINT32 positionLat) + { + SetFieldSINT32Value(2, positionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLongValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLong(void) const + { + return GetFieldSINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLong(FIT_SINT32 positionLong) + { + SetFieldSINT32Value(3, positionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDistance(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDistance(FIT_FLOAT32 distance) + { + SetFieldFLOAT32Value(4, distance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_COURSE_POINT GetType(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_COURSE_POINT type) + { + SetFieldENUMValue(5, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(6, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of favorite field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFavoriteValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns favorite field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetFavorite(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set favorite field + /////////////////////////////////////////////////////////////////////// + void SetFavorite(FIT_BOOL favorite) + { + SetFieldENUMValue(8, favorite, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_COURSE_POINT_MESG_HPP) diff --git a/fit_course_point_mesg_listener.hpp b/fit_course_point_mesg_listener.hpp new file mode 100644 index 0000000..fdd6715 --- /dev/null +++ b/fit_course_point_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_COURSE_POINT_MESG_LISTENER_HPP) +#define FIT_COURSE_POINT_MESG_LISTENER_HPP + +#include "fit_course_point_mesg.hpp" + +namespace fit +{ + +class CoursePointMesgListener +{ +public: + virtual ~CoursePointMesgListener() {} + virtual void OnMesg(CoursePointMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_COURSE_POINT_MESG_LISTENER_HPP) diff --git a/fit_crc.cpp b/fit_crc.cpp new file mode 100644 index 0000000..597a1a0 --- /dev/null +++ b/fit_crc.cpp @@ -0,0 +1,60 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_crc.hpp" + +namespace fit +{ + +FIT_UINT16 CRC::Get16(FIT_UINT16 crc, FIT_UINT8 byte) +{ + static const FIT_UINT16 crc_table[16] = + { + 0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401, + 0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400 + }; + FIT_UINT16 tmp; + + // compute checksum of lower four bits of byte + tmp = crc_table[crc & 0xF]; + crc = (crc >> 4) & 0x0FFF; + crc = crc ^ tmp ^ crc_table[byte & 0xF]; + + // now compute checksum of upper four bits of byte + tmp = crc_table[crc & 0xF]; + crc = (crc >> 4) & 0x0FFF; + crc = crc ^ tmp ^ crc_table[(byte >> 4) & 0xF]; + + return crc; +} + +FIT_UINT16 CRC::Calc16(const volatile void *data, FIT_UINT32 size) +{ + FIT_UINT16 crc = 0; + FIT_BYTE *data_ptr = (FIT_BYTE *)data; + + while (size) + { + crc = CRC::Get16(crc, *data_ptr); + data_ptr++; + size--; + } + + return crc; +} + +} // namespace fit + +#if defined(FIT_CPP_INCLUDE_C) + // Include C Implementation + #include "fit_crc.c" +#endif diff --git a/fit_crc.hpp b/fit_crc.hpp new file mode 100644 index 0000000..636a466 --- /dev/null +++ b/fit_crc.hpp @@ -0,0 +1,31 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_CRC_HPP) +#define FIT_CRC_HPP + +#include "fit.hpp" + +namespace fit +{ + +class CRC +{ + public: + static FIT_UINT16 Get16(FIT_UINT16 crc, FIT_UINT8 byte); + static FIT_UINT16 Calc16(const volatile void *data, FIT_UINT32 size); +}; + + +} // namespace fit + +#endif // !defined(FIT_CRC_HPP) diff --git a/fit_date_time.cpp b/fit_date_time.cpp new file mode 100644 index 0000000..69d62b3 --- /dev/null +++ b/fit_date_time.cpp @@ -0,0 +1,124 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_date_time.hpp" + +namespace fit +{ + +DateTime::DateTime(time_t timeStamp) +{ + this->timeStamp = (FIT_DATE_TIME) (timeStamp - systemTimeOffset); + this->fractionalTimeStamp = 0.0; +} + +DateTime::DateTime(FIT_DATE_TIME timeStamp) +{ + this->timeStamp = timeStamp; + this->fractionalTimeStamp = 0.0; +} + +DateTime::DateTime(FIT_DATE_TIME timeStamp, FIT_FLOAT64 fractionalTimeStamp) +{ + this->timeStamp = timeStamp + (FIT_DATE_TIME) floor(fractionalTimeStamp); + this->fractionalTimeStamp = fractionalTimeStamp - (FIT_FLOAT64) floor(fractionalTimeStamp); +} + +DateTime::DateTime(const DateTime& dateTime) +{ + timeStamp = dateTime.timeStamp; + fractionalTimeStamp = dateTime.fractionalTimeStamp; +} + +bool DateTime::Equals(DateTime dateTime) +{ + return( ( ( this->timeStamp == dateTime.GetTimeStamp() ) && ( this->fractionalTimeStamp == dateTime.GetFractionalTimestamp() ) ) ); +} + +FIT_DATE_TIME DateTime::GetTimeStamp() +{ + return timeStamp; +} + +FIT_FLOAT64 DateTime::GetFractionalTimestamp() +{ + return fractionalTimeStamp; +} + +void DateTime::add(DateTime dateTime) +{ + this->timeStamp += dateTime.GetTimeStamp(); + this->fractionalTimeStamp += dateTime.GetFractionalTimestamp(); + + // Adjust fractional part to be less that 1 + this->timeStamp += (long)floor(this->fractionalTimeStamp); + this->fractionalTimeStamp -= (float)floor(this->fractionalTimeStamp); +} + +void DateTime::add(FIT_DATE_TIME timestamp) +{ + add(DateTime(timestamp)); +} + +void DateTime::add(double fractional_timestamp) +{ + add(DateTime(0, fractional_timestamp)); +} + +time_t DateTime::GetTimeT() +{ + double val; + if (fractionalTimeStamp >= 0.5) + val = ceil(fractionalTimeStamp); + else + val = 0; + return (time_t)(timeStamp + systemTimeOffset + val); +} + +void DateTime::ConvertSystemTimeToUTC(long offset) +{ + if (timeStamp < FIT_DATE_TIME_MIN) + { + timeStamp += offset; + } +} + +//Returns 0 if DateTimes are equal +//Returns -1 if t1 > target object (this) +//Returns 1 if target object (this) > t1 +//If timeStamps are equal, fractional timestamps are compared +int DateTime::CompareTo(DateTime t1) { + // fractional_timestamp is guaranteed to be less that 1 which allows simplified comparison below + if ( this->timeStamp == t1.GetTimeStamp() ) { + // Timestamps are equal; must compare fractional part. + if (this->fractionalTimeStamp < t1.GetFractionalTimestamp()) + { + return -1; + } + else if (this->fractionalTimeStamp > t1.GetFractionalTimestamp()) + { + return 1; + } + else + { + return 0; + } + } + else if ( this->timeStamp > t1.GetTimeStamp() ) { + return 1; + } + else { + return -1; + } +} + +} // namespace fit diff --git a/fit_date_time.hpp b/fit_date_time.hpp new file mode 100644 index 0000000..1201488 --- /dev/null +++ b/fit_date_time.hpp @@ -0,0 +1,47 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DATE_TIME_HPP) +#define FIT_DATE_TIME_HPP + +#include +#include +#include "fit_profile.hpp" +namespace fit +{ + +class DateTime +{ + public: + DateTime(time_t timeStamp); + DateTime(FIT_DATE_TIME timeStamp); + DateTime(FIT_DATE_TIME timeStamp, FIT_FLOAT64 fractionalTimeStamp); + DateTime(const DateTime& dateTime); + bool Equals(DateTime dateTime); + FIT_DATE_TIME GetTimeStamp(); + FIT_FLOAT64 GetFractionalTimestamp(); + void add(DateTime dateTime); + void add(FIT_DATE_TIME timestamp); + void add(double fractional_timestamp); + time_t GetTimeT(); + void ConvertSystemTimeToUTC(long offset); + int CompareTo(DateTime t1); + + private: + FIT_DATE_TIME timeStamp; + FIT_FLOAT64 fractionalTimeStamp; + static const time_t systemTimeOffset = 631065600; // Needed for conversion from UNIX time to FIT time +}; + +} // namespace fit + +#endif // !defined(FIT_DATE_TIME_HPP) diff --git a/fit_decode.cpp b/fit_decode.cpp new file mode 100644 index 0000000..63e735e --- /dev/null +++ b/fit_decode.cpp @@ -0,0 +1,1084 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + + +#include +#include +#include "fit_decode.hpp" +#include "fit_crc.hpp" +#include "fit_mesg_listener.hpp" +#include "fit_developer_data_id_mesg.hpp" +#include "fit_developer_field.hpp" + + +namespace fit +{ + +const FIT_UINT8 Decode::DevFieldNumOffset = 0; +const FIT_UINT8 Decode::DevFieldSizeOffset = 1; +const FIT_UINT8 Decode::DevFieldIndexOffset = 2; + +Decode::Decode() + : mesgListener(NULL) + , mesgDefinitionListener(NULL) +{ + for (int i=0; ifile = file; + currentByteOffset = 0; + descriptions.clear(); + developers.clear(); + + // Read out the size of the file + file->seekg(0, file->end); + fileSize = (FIT_UINT32)file->tellg(); + // Ensure the read starts at the beginning of the file + file->seekg(0, file->beg); + + while ( ( currentByteOffset < fileSize ) && ( status == FIT_TRUE ) ) + { + InitRead(*file, FIT_FALSE); + status = Resume(); + } + + return status; +} + +FIT_BOOL Decode::Read + ( + std::istream* file, + MesgListener* mesgListener, + MesgDefinitionListener* definitionListener, + DeveloperFieldDescriptionListener* descriptionListener + ) +{ + this->mesgListener = mesgListener; + this->mesgDefinitionListener = definitionListener; + this->descriptionListener = descriptionListener; + + return Read(file); +} + +FIT_BOOL Decode::Read(std::istream &file, MesgListener& mesgListener) +{ + return Read(&file, &mesgListener, nullptr, nullptr); +} + +FIT_BOOL Decode::Read(std::istream &file, MesgListener& mesgListener, MesgDefinitionListener& mesgDefinitionListener) +{ + return Read(&file, &mesgListener, &mesgDefinitionListener, nullptr); +} + + +void Decode::Pause(void) +{ + pause = FIT_TRUE; +} + +FIT_BOOL Decode::Resume(void) +{ + pause = FIT_FALSE; + RETURN decodeReturn = RETURN_CONTINUE; + + do + { + if ( currentByteIndex == 0 ) + { + file->read(buffer, BufferSize); + bytesRead = (FIT_UINT32)file->gcount(); + } + + for (; currentByteIndex < bytesRead; currentByteIndex++) + { + if (pause) + return FIT_FALSE; + + decodeReturn = ReadByte((FIT_UINT8)buffer[currentByteIndex]); + + switch (decodeReturn) { + case RETURN_CONTINUE: + break; + + case RETURN_MESG: + if (mesg.GetNum() == FIT_MESG_NUM_DEVELOPER_DATA_ID) + { + DeveloperDataIdMesg devIdMesg(mesg); + + if (!devIdMesg.IsDeveloperDataIndexValid()) { + throw fit::RuntimeException("Invalid developer data index in DeveloperDataIdMesg"); + } + + FIT_UINT8 index = devIdMesg.GetDeveloperDataIndex(); + developers[index] = devIdMesg; + descriptions[index] = std::unordered_map(); + } + else if (mesg.GetNum() == FIT_MESG_NUM_FIELD_DESCRIPTION) + { + FieldDescriptionMesg descMesg(mesg); + + if (!descMesg.IsDeveloperDataIndexValid()) { + throw fit::RuntimeException("Invalid developer data index in FieldDescriptionMesg"); + } + + if (!descMesg.IsFieldDefinitionNumberValid()) + { + throw fit::RuntimeException("Invalid developer field definition number in FieldDescriptionMesg"); + } + + FIT_UINT8 index = descMesg.GetDeveloperDataIndex(); + FIT_UINT8 fldNum = descMesg.GetFieldDefinitionNumber(); + + try + { + descriptions.at(index)[fldNum] = descMesg; + + + if (descriptionListener) + { + descriptionListener->OnDeveloperFieldDescription(DeveloperFieldDescription(descMesg, developers[index])); + } + } + catch (std::out_of_range) + { + // Description without a Developer Data Id Message + } + } + + + + if (mesgListener) + mesgListener->OnMesg(mesg); + break; + + case RETURN_MESG_DEF: + + if (mesgDefinitionListener) + { + mesgDefinitionListener->OnMesgDefinition(localMesgDefs[localMesgIndex]); + } + break; + + case RETURN_END_OF_FILE: + // Increment so we do not read the same byte twice in the case of a chained file + currentByteIndex++; + currentByteOffset++; + return FIT_TRUE; + + default: + currentByteOffset++; + return FIT_TRUE; + } + currentByteOffset++; + } + currentByteIndex = 0; + } while ( file->good() ); + + if ((streamIsComplete == FIT_TRUE) && (skipHeader == FIT_FALSE)) + { + // When decoding a complete file we should exit via RETURN_END_OF_FILE state only. + std::ostringstream message; + message << "FIT decode error: Unexpected end of input stream at byte: " << currentByteOffset; + throw RuntimeException(message.str()); + } + if (streamIsComplete == FIT_FALSE) + { + // If stream is not yet complete caller can resume() when there is more data + // or decide there was an error. + if ((decodeReturn == RETURN_MESG) || (decodeReturn == RETURN_MESG_DEF)) + { + // Our stream ended on a complete message, maybe we are done decoding. + return FIT_TRUE; + } + else + { + // EOF was encountered mid message. Caller may want to resume once + // more bytes are available. + return FIT_FALSE; + } + } + // if Decoding Records section only, file should end on a complete message + // (unless incomplete stream option above was also used) + else + { + if ((decodeReturn == RETURN_MESG) || (decodeReturn == RETURN_MESG_DEF)) + { + // Our stream ended on a complete message, we are done decoding. + return FIT_TRUE; + } + else + { + if (invalidDataSize == FIT_FALSE) + { + std::ostringstream message; + message << "FIT decode error: Unexpected end of input stream at byte: " << currentByteOffset; + throw RuntimeException(message.str()); + } + else + { + return FIT_TRUE; + } + } + } +} + +FIT_BOOL Decode::getInvalidDataSize(void) +{ + return invalidDataSize; +} + +void Decode::setInvalidDataSize(FIT_BOOL value) +{ + invalidDataSize = value; +} + +void Decode::InitRead(std::istream &file) +{ + InitRead(file, FIT_TRUE); +} + +void Decode::InitRead(std::istream &file, FIT_BOOL startOfFile) +{ + fileBytesLeft = 3; // Header byte + CRC. + fileHdrOffset = 0; + crc = 0; + headerException = ""; + // Only reset to header state if we do not want + // to skip the header. + if (skipHeader == FIT_FALSE) + state = STATE_FILE_HDR; + lastTimeOffset = 0; + + // Reset to the beginning of the file + if ( startOfFile == FIT_TRUE) + { + file.seekg(0, file.beg); + } + + file.clear(); // workaround libc++ issue +} + +void Decode::UpdateEndianness(FIT_UINT8 type, FIT_UINT8 size) +{ + FIT_UINT8 typeSize = baseTypeSizes[type & FIT_BASE_TYPE_NUM_MASK]; + FIT_UINT8 numElements = size / typeSize; + + if (((type & FIT_BASE_TYPE_ENDIAN_FLAG) != 0) && + ((archs[localMesgIndex] & FIT_ARCH_ENDIAN_MASK) != FIT_ARCH_ENDIAN_LITTLE)) + { + // Swap the bytes for each element. + for (int element = 0; element < numElements; element++) + { + for (int i = 0; i < (typeSize / 2); i++) + { + FIT_UINT8 tmp = fieldData[element * typeSize + i]; + fieldData[element * typeSize + i] = fieldData[element * typeSize + typeSize - i - 1]; + fieldData[element * typeSize + typeSize - i - 1] = tmp; + } + } + } +} + +Decode::RETURN Decode::ReadByte(FIT_UINT8 data) +{ + if ((fileBytesLeft > 0) && (skipHeader == FIT_FALSE)) + { + crc = CRC::Get16(crc, data); + + fileBytesLeft--; + + if (fileBytesLeft == 1) // CRC low byte. + { + if (state != STATE_RECORD) + { + std::ostringstream message; + message << "FIT decode error: Decoder not in correct state after last data byte in file. Check message definitions. Error at byte: " << currentByteOffset; + throw(RuntimeException(message.str())); + } + + return RETURN_CONTINUE; // Next byte. + } + + if (fileBytesLeft == 0) // CRC high byte. + { + if (crc != 0) + { + std::ostringstream message; + message << "FIT decode error: File CRC failed. Error at byte: " << currentByteOffset; + throw(RuntimeException(message.str())); + } + + return RETURN_END_OF_FILE; + } + } + + switch (state) { + case STATE_FILE_HDR: + switch (fileHdrOffset++) + { + case 0: + if( data < FIT_HEADER_SIZE_NO_CRC ) + { + std::ostringstream message; + message << "FIT decode error: File header size invalid. File is not FIT. Error at byte : " << currentByteOffset; + headerException = message.str(); + } + else + { + fileHdrSize = data; + fileBytesLeft = fileHdrSize + 2; + } + break; + case 1: + if ((data & FIT_PROTOCOL_VERSION_MAJOR_MASK) > (FIT_PROTOCOL_VERSION_MAJOR << FIT_PROTOCOL_VERSION_MAJOR_SHIFT)) + { + std::ostringstream message; + message << "FIT decode error: Protocol version " << (data & FIT_PROTOCOL_VERSION_MAJOR_MASK) << FIT_PROTOCOL_VERSION_MAJOR_SHIFT << "." << (data & FIT_PROTOCOL_VERSION_MINOR_MASK) << " not supported. Must be " << FIT_PROTOCOL_VERSION_MAJOR << ".15 or earlier."; + headerException = message.str(); + } + break; + case 4: + fileDataSize = data & 0xFF; + break; + case 5: + fileDataSize |= (FIT_UINT32) (data & 0xFF) << 8; + break; + case 6: + fileDataSize |= (FIT_UINT32) (data & 0xFF) << 16; + break; + case 7: + fileDataSize |= (FIT_UINT32) (data & 0xFF) << 24; + if ( (fileDataSize == 0) && (invalidDataSize == FIT_FALSE) ) + { + invalidDataSize = FIT_TRUE; + std::ostringstream message; + message << "FIT decode error: File Size is 0. Error at byte : " << currentByteOffset; + headerException = message.str(); + } + break; + case 8: + if (data != '.') + { + std::ostringstream message; + message << "FIT decode error: File header signature mismatch. File is not FIT. Error at byte : " << currentByteOffset; + headerException = message.str(); + } + break; + case 9: + if (data != 'F') + { + std::ostringstream message; + message << "FIT decode error: File header signature mismatch. File is not FIT. Error at byte : " << currentByteOffset; + headerException = message.str(); + } + break; + case 10: + if (data != 'I') + { + std::ostringstream message; + message << "FIT decode error: File header signature mismatch. File is not FIT. Error at byte : " << currentByteOffset; + headerException = message.str(); + } + break; + case 11: + if (data != 'T') + { + std::ostringstream message; + message << "FIT decode error: File header signature mismatch. File is not FIT. Error at byte : " << currentByteOffset; + headerException = message.str(); + } + + if (headerException != "") + { + throw(RuntimeException(headerException)); + } + break; + default: + break; + } + + if (fileHdrOffset == fileHdrSize) + { + fileBytesLeft = fileDataSize + 2; // include crc + state = STATE_RECORD; + + // We don't care about the CRC when the file size is invalid + if (invalidDataSize) + { + skipHeader = FIT_TRUE; + } + } + break; + + case STATE_RECORD: + fieldIndex = 0; + fieldBytesLeft = 0; + + if (fileBytesLeft > 1) { + if ((data & FIT_HDR_TIME_REC_BIT) != 0) { + Field timestampField = Field(Profile::MESG_RECORD, Profile::RECORD_MESG_TIMESTAMP); + FIT_UINT8 timeOffset = data & FIT_HDR_TIME_OFFSET_MASK; + + timestamp += (timeOffset - lastTimeOffset) & FIT_HDR_TIME_OFFSET_MASK; + lastTimeOffset = timeOffset; + timestampField.SetUINT32Value(timestamp); + + localMesgIndex = (data & FIT_HDR_TIME_TYPE_MASK) >> FIT_HDR_TIME_TYPE_SHIFT; + + if (localMesgDefs[localMesgIndex].GetNum() == FIT_MESG_NUM_INVALID) + { + std::ostringstream message; + message << "FIT decode error: Missing FIT message definition for local message number " << ((int)localMesgIndex) << ". Error at byte: " << currentByteOffset; + throw(RuntimeException(message.str())); + } + + mesg = Mesg(localMesgDefs[localMesgIndex].GetNum()); + mesg.SetLocalNum(localMesgIndex); + mesg.AddField(timestampField); + + if (localMesgDefs[localMesgIndex].GetFields().size() == 0) + return RETURN_MESG; + + state = STATE_FIELD_DATA; + } + else + { + localMesgIndex = data & FIT_HDR_TYPE_MASK; + + if ((data & FIT_HDR_TYPE_DEF_BIT) != 0) + { + hasDevData = ((data & FIT_HDR_DEV_FIELD_BIT) != 0); + state = STATE_RESERVED1; + } + else + { + if (localMesgDefs[localMesgIndex].GetNum() == FIT_MESG_NUM_INVALID) + { + std::ostringstream message; + message << "FIT decode error: Missing FIT message definition for local message number " << ((int)localMesgIndex) << ". Error at byte: " << currentByteOffset; + throw(RuntimeException(message.str())); + } + + mesg = Mesg(localMesgDefs[localMesgIndex].GetNum()); + mesg.SetLocalNum(localMesgIndex); + + if (localMesgDefs[localMesgIndex].GetFields().size() != 0) + { + state = STATE_FIELD_DATA; + } + else if (localMesgDefs[localMesgIndex].GetDeveloperFieldTotalSize() > 0) + { + state = STATE_DEV_FIELD_DATA; + } + else + { + return RETURN_MESG; + } + } + } + } + else + { + // We just got the low byte of the crc. + state = STATE_FILE_CRC_HIGH; + } + break; + + case STATE_RESERVED1: + localMesgDefs[localMesgIndex].ClearFields(); + state = STATE_ARCH; + break; + + case STATE_ARCH: + archs[localMesgIndex] = data; + state = STATE_MESG_NUM_0; + break; + + case STATE_MESG_NUM_0: + // Read the global message number bytes in as if they are in little endian format. + localMesgDefs[localMesgIndex].SetNum((FIT_UINT16)data); + state = STATE_MESG_NUM_1; + break; + + case STATE_MESG_NUM_1: + localMesgDefs[localMesgIndex].SetNum(localMesgDefs[localMesgIndex].GetNum() | ((FIT_UINT16)data << 8)); + + // We have to check for endianness. + if (archs[localMesgIndex] == FIT_ARCH_ENDIAN_BIG) { + localMesgDefs[localMesgIndex].SetNum((localMesgDefs[localMesgIndex].GetNum() >> 8) | ((localMesgDefs[localMesgIndex].GetNum() & 0xFF) << 8)); + } + else if (archs[localMesgIndex] != FIT_ARCH_ENDIAN_LITTLE) + { + std::ostringstream message; + message << "FIT decode error: Architecture " << archs[localMesgIndex] << " not supported. Error at byte: " << currentByteOffset; + throw(RuntimeException(message.str())); + } + + state = STATE_NUM_FIELDS; + break; + + case STATE_NUM_FIELDS: + numFields = data; + fieldIndex = 0; + + if (numFields == 0) + { + if (hasDevData) + { + state = STATE_NUM_DEV_FIELDS; + } + else + { + state = STATE_RECORD; + return RETURN_MESG_DEF; + } + } + else + { + state = STATE_FIELD_NUM; + } + break; + + case STATE_FIELD_NUM: + localMesgDefs[localMesgIndex].AddField(FieldDefinition()); + localMesgDefs[localMesgIndex].GetFieldByIndex(fieldIndex)->SetNum(data); + state = STATE_FIELD_SIZE; + break; + + case STATE_FIELD_SIZE: + if ( data == 0 ) + { + // Bad Size + std::ostringstream message; + message << "FIT decode error: Invalid Field Size " << data << ". Error at byte: " << currentByteOffset; + throw(RuntimeException(message.str())); + } + + localMesgDefs[localMesgIndex].GetFieldByIndex(fieldIndex)->SetSize(data); + state = STATE_FIELD_TYPE; + break; + + case STATE_FIELD_TYPE: + localMesgDefs[localMesgIndex].GetFieldByIndex(fieldIndex)->SetType(data); + + if (++fieldIndex >= numFields) + { + if (hasDevData) + { + state = STATE_NUM_DEV_FIELDS; + } + else + { + state = STATE_RECORD; + return RETURN_MESG_DEF; + } + } + else + { + state = STATE_FIELD_NUM; + } + break; + + case STATE_NUM_DEV_FIELDS: + numFields = data; + fieldIndex = 0; + + if (numFields == 0) + { + state = STATE_RECORD; + return RETURN_MESG_DEF; + } + + state = STATE_DEV_FIELD_NUM; + break; + + case STATE_DEV_FIELD_NUM: + fieldData[DevFieldNumOffset] = data; + state = STATE_DEV_FIELD_SIZE; + break; + + case STATE_DEV_FIELD_SIZE: + fieldData[DevFieldSizeOffset] = data; + state = STATE_DEV_FIELD_INDEX; + break; + + case STATE_DEV_FIELD_INDEX: + fieldData[DevFieldIndexOffset] = data; + + try + { + const FieldDescriptionMesg& desc = descriptions + .at(fieldData[DevFieldIndexOffset]) + .at(fieldData[DevFieldNumOffset]); + const DeveloperDataIdMesg& developer = developers + .at( fieldData[DevFieldIndexOffset] ); + + localMesgDefs[localMesgIndex] + .AddDevField(DeveloperFieldDefinition(desc, developer, fieldData[DevFieldSizeOffset])); + } + catch (std::out_of_range) + { + // No Matching Description Message add a Generic Definition + localMesgDefs[localMesgIndex] + .AddDevField(DeveloperFieldDefinition( + fieldData[DevFieldNumOffset], + fieldData[DevFieldSizeOffset], + fieldData[DevFieldIndexOffset])); + } + + if (++fieldIndex >= numFields) + { + state = STATE_RECORD; + return RETURN_MESG_DEF; + } + + state = STATE_DEV_FIELD_NUM; + break; + + case STATE_FIELD_DATA: + if (fieldBytesLeft == 0) + { + fieldDataIndex = 0; + fieldBytesLeft = localMesgDefs[localMesgIndex].GetFieldByIndex(fieldIndex)->GetSize(); + + if (fieldBytesLeft == 0) + { + fieldBytesLeft = localMesgDefs[localMesgIndex].GetFieldByIndex(++fieldIndex)->GetSize(); + } + } + + fieldData[fieldDataIndex++] = data; + fieldBytesLeft--; + + if (fieldBytesLeft == 0) + { + MesgDefinition defn = localMesgDefs[localMesgIndex]; + FieldDefinition* fldDefn = defn.GetFieldByIndex(fieldIndex); + FIT_UINT8 baseType = fldDefn->GetType() & FIT_BASE_TYPE_NUM_MASK; + FIT_UINT8 typeSize = baseTypeSizes[baseType]; + FIT_BOOL read = FIT_TRUE; + + if (baseType < FIT_BASE_TYPES) // Ignore field if base type not supported. + { + UpdateEndianness(fldDefn->GetType(), fldDefn->GetSize()); + + Field field(mesg.GetNum(), fldDefn->GetNum()); + if (field.IsValid()) // If known field type. + { + if ( field.GetType() != fldDefn->GetType() ) + { + FIT_UINT8 profileSize = fit::baseTypeSizes[( field.GetType() & FIT_BASE_TYPE_NUM_MASK )]; + if ( typeSize < profileSize ) + { + field.SetBaseType( fldDefn->GetType() ); + } + else if ( typeSize != profileSize ) + { + // Demotion is hard. Don't read the field if the + // sizes are different. Use the profile type if the + // signedness of the field has changed. + read = FIT_FALSE; + } + } + + if ( read ) + { + field.Read(&fieldData, defn.GetFieldByIndex(fieldIndex)->GetSize()); + } + + // The special case time record. + if (defn.GetFieldByIndex(fieldIndex)->GetNum() == FIT_FIELD_NUM_TIMESTAMP) + { + timestamp = field.GetUINT32Value(); + lastTimeOffset = (FIT_UINT8)(timestamp & FIT_HDR_TIME_OFFSET_MASK); + } + + //Allows messages containing the accumulated field to set the accumulated value + if ( field.GetIsAccumulated() ) + { + FIT_UINT8 i; + for (i = 0; i < field.GetNumValues(); i++) + { + FIT_FLOAT64 value = field.GetRawValue(i); + FIT_UINT16 j; + for (j = 0; j < mesg.GetNumFields(); j++) + { + FIT_UINT16 k; + Field* containingField = mesg.GetFieldByIndex(j); + FIT_UINT16 numComponents = containingField->GetNumComponents(); + + for (k = 0; k < numComponents; k++) + { + const Profile::FIELD_COMPONENT* fc = containingField->GetComponent(k); + if ( ( fc->num == field.GetNum() ) && ( fc->accumulate ) ) + { + value = ((((value / field.GetScale()) - field.GetOffset()) + fc->offset) * fc->scale); + } + } + } + accumulator.Set(mesg.GetNum(), field.GetNum(), (FIT_UINT32)value); + } + } + + if (field.GetNumValues() > 0) + { + mesg.AddField(field); + } + } + } + fieldIndex++; + } + + if (fieldIndex >= localMesgDefs[localMesgIndex].GetFields().size()) + { + // Now that the entire message is decoded we may evaluate subfields and expand components + for (FIT_UINT16 i=0; iGetNumComponents() > 0) + { + ExpandComponents(mesg.GetFieldByIndex(i), mesg.GetFieldByIndex(i)->GetComponent(0), mesg.GetFieldByIndex(i)->GetNumComponents()); + } + } + else + { + if (mesg.GetFieldByIndex(i)->GetSubField(activeSubField)->numComponents > 0) + { + ExpandComponents(mesg.GetFieldByIndex(i), mesg.GetFieldByIndex(i)->GetSubField(activeSubField)->components, mesg.GetFieldByIndex(i)->GetSubField(activeSubField)->numComponents); + } + } + } + } + + if (localMesgDefs[localMesgIndex].GetDeveloperFieldTotalSize() > 0) + { + fieldIndex = 0; + fieldBytesLeft = 0; + state = STATE_DEV_FIELD_DATA; + } + else + { + state = STATE_RECORD; + return RETURN_MESG; + } + } + break; + + case STATE_DEV_FIELD_DATA: { + MesgDefinition& localMesgDef = localMesgDefs[localMesgIndex]; + DeveloperFieldDefinition* fieldDef = localMesgDef.GetDevFieldByIndex(fieldIndex); + + if (fieldBytesLeft == 0) + { + fieldDataIndex = 0; + fieldBytesLeft = fieldDef->GetSize(); + + if (fieldBytesLeft == 0) + { + fieldBytesLeft = localMesgDefs-> + GetDevFieldByIndex(++fieldIndex)->GetSize(); + } + } + + fieldData[fieldDataIndex++] = data; + fieldBytesLeft--; + + if (fieldBytesLeft == 0) + { + MesgDefinition defn = localMesgDefs[localMesgIndex]; + DeveloperFieldDefinition* fldDefn = defn.GetDevFieldByIndex(fieldIndex); + FIT_UINT8 baseType = fldDefn->GetType() & FIT_BASE_TYPE_NUM_MASK; + + if (baseType < FIT_BASE_TYPES) // Ignore field if base type not supported. + { + DeveloperField field(*fldDefn); + + UpdateEndianness(fldDefn->GetType(), fldDefn->GetSize()); + field.Read(&fieldData, fldDefn->GetSize()); + mesg.AddDeveloperField(field); + } + + fieldIndex++; + + if (fieldIndex >= localMesgDef.GetDevFields().size()) { + // Mesg decode complete + state = STATE_RECORD; + return RETURN_MESG; + } + } + break; + } + + default: + break; + } + + return RETURN_CONTINUE; +} + +void Decode::SuppressComponentExpansion(void) +{ + suppressComponentExpansion = FIT_TRUE; +} + +void Decode::ExpandComponents(Field* containingField, const Profile::FIELD_COMPONENT* components, FIT_UINT16 numComponents) +{ + FIT_UINT16 offset = 0; + FIT_UINT16 i; + + for (i = 0; i < numComponents; i++) + { + const Profile::FIELD_COMPONENT* component = &components[i]; + + if (component->num != FIT_FIELD_NUM_INVALID) + { + Field componentField(mesg.GetNum(), component->num); + FIT_UINT16 subfieldIndex = mesg.GetActiveSubFieldIndex( componentField.GetNum() ); + FIT_FLOAT64 value; + FIT_UINT32 bitsValue = FIT_UINT32_INVALID; + FIT_SINT32 signedBitsValue = FIT_SINT32_INVALID; + + // Mark that this field has been generated through expansion + componentField.SetIsExpanded(FIT_TRUE); + + if (componentField.IsSignedInteger()) + { + signedBitsValue = containingField->GetBitsSignedValue(offset, component->bits); + + if (signedBitsValue == FIT_SINT32_INVALID) + break; // No more data for components. + + if (component->accumulate) + bitsValue = accumulator.Accumulate(mesg.GetNum(), component->num, signedBitsValue, component->bits); + } + else + { + bitsValue = containingField->GetBitsValue(offset, component->bits); + + if (bitsValue == FIT_UINT32_INVALID) + break; // No more data for components. + + if (component->accumulate) + bitsValue = accumulator.Accumulate(mesg.GetNum(), component->num, bitsValue, component->bits); + } + + // If the component field itself has *one* component apply the scale and offset of the componentField's + // (nested) component + if (componentField.GetNumComponents() == 1) + { + if(componentField.IsSignedInteger()) + value = (((signedBitsValue / (FIT_FLOAT64)component->scale) - component->offset) + componentField.GetComponent(0)->offset) * componentField.GetComponent(0)->scale; + else + value = (((bitsValue / (FIT_FLOAT64)component->scale) - component->offset) + componentField.GetComponent(0)->offset) * componentField.GetComponent(0)->scale; + if (mesg.HasField(componentField.GetNum())) + { + fit::Field *currentField = mesg.GetField(componentField.GetNum()); + currentField->AddRawValue(value, currentField->GetNumValues()); + } + else + { + componentField.AddRawValue(value, componentField.GetNumValues()); + mesg.AddField(componentField); + } + } + // The component field is itself a composite field (more than one component). Don't use scale/offset, containing + // field data must already be encoded. Add elements to it until we have added bitsvalue + else if (componentField.GetNumComponents() > 1) + { + int bitsAdded = 0; + long mask; + + while (bitsAdded < component->bits) + { + mask = ((long)1 << baseTypeSizes[componentField.GetType() & FIT_BASE_TYPE_NUM_MASK]) - 1; + if (mesg.HasField(componentField.GetNum())) + { + Field* field = mesg.GetField( componentField.GetNum() ); + field->AddValue( bitsValue & mask, field->GetNumValues() ); + } + else + { + componentField.AddValue(bitsValue & mask, componentField.GetNumValues()); + mesg.AddField(componentField); + } + bitsValue >>= baseTypeSizes[componentField.GetType() & FIT_BASE_TYPE_NUM_MASK]; + bitsAdded += baseTypeSizes[componentField.GetType() & FIT_BASE_TYPE_NUM_MASK]; + } + } + // componentField is an ordinary field, apply scale and offset as usual + else + { + if(componentField.IsSignedInteger()) + value = (((signedBitsValue / (FIT_FLOAT64)component->scale) - component->offset) + componentField.GetOffset(subfieldIndex)) * componentField.GetScale(subfieldIndex); + else + value = (((bitsValue / (FIT_FLOAT64)component->scale) - component->offset) + componentField.GetOffset(subfieldIndex)) * componentField.GetScale(subfieldIndex); + if (mesg.HasField(componentField.GetNum())) + { + fit::Field *currentField = mesg.GetField(componentField.GetNum()); + currentField->AddRawValue(value, currentField->GetNumValues()); + } + else + { + componentField.AddRawValue(value, componentField.GetNumValues()); + mesg.AddField(componentField); + } + } + } + offset += component->bits; + } +} + +} // namespace fit diff --git a/fit_decode.hpp b/fit_decode.hpp new file mode 100644 index 0000000..fb0fbb0 --- /dev/null +++ b/fit_decode.hpp @@ -0,0 +1,225 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DECODE_HPP) +#define FIT_DECODE_HPP + +#include +#include +#include +#include "fit.hpp" +#include "fit_accumulator.hpp" +#include "fit_field.hpp" +#include "fit_mesg.hpp" +#include "fit_mesg_definition.hpp" +#include "fit_mesg_definition_listener.hpp" +#include "fit_developer_field_description_listener.hpp" +#include "fit_mesg_listener.hpp" +#include "fit_runtime_exception.hpp" +#include "fit_developer_data_id_mesg.hpp" + +namespace fit +{ +class Decode +{ +public: + Decode(); + + FIT_BOOL IsFIT(std::istream &file); + /////////////////////////////////////////////////////////////////////// + // Reads the file header to check if the file is FIT. + // Does not check CRC. + // Parameters: + // file Pointer to file to read. + // Returns true if file is FIT. + /////////////////////////////////////////////////////////////////////// + + FIT_BOOL CheckIntegrity(std::istream &file); + /////////////////////////////////////////////////////////////////////// + // Reads the FIT binary file header and crc to check compatibility and integrity. + // Parameters: + // file Pointer to file to read. + // Returns true if file is ok (not corrupt). + /////////////////////////////////////////////////////////////////////// + + void SkipHeader(); + /////////////////////////////////////////////////////////////////////// + // Overrides the default read behaviour by skipping header decode. + // CRC checking is not possible since the datasize is unknown. + // Decode continues until EOF is encountered or a decode error occurs. + // May only be called prior to calling Read. + /////////////////////////////////////////////////////////////////////// + + void IncompleteStream(); + /////////////////////////////////////////////////////////////////////// + // Override the default read behaviour allowing decode of partial streams. + // If EOF is encountered no exception is raised. Caller may choose to call + // resume possibly after more bytes have arrived in the stream. May only be set + // prior to first calling Read. + /////////////////////////////////////////////////////////////////////// + + void SuppressComponentExpansion(void); + /////////////////////////////////////////////////////////////////////// + // Override the default read behaviour by suppressing the component expansion + // If your application does not care about component expansion this can speed + // up processing significantly. + /////////////////////////////////////////////////////////////////////// + + FIT_BOOL Read(std::istream &file, MesgListener& mesgListener); + /////////////////////////////////////////////////////////////////////// + // Reads a FIT binary file. + // Parameters: + // file Pointer to file to read. + // mesgListener Message listener + // Returns true if finished read file, otherwise false if decoding is paused. + /////////////////////////////////////////////////////////////////////// + + FIT_BOOL Read(std::istream &file, MesgListener& mesgListener, MesgDefinitionListener& mesgDefinitionListener); + /////////////////////////////////////////////////////////////////////// + // Reads a FIT binary file. + // Parameters: + // file Pointer to file to read. + // mesgListener Message listener + // mesgDefinitionListener Message definition listener + // Returns true if finished read file, otherwise false if decoding is paused. + /////////////////////////////////////////////////////////////////////// + + FIT_BOOL Read + ( + std::istream* file, + MesgListener* mesgListener, + MesgDefinitionListener* definitionListener, + DeveloperFieldDescriptionListener* descriptionListener + ); + /////////////////////////////////////////////////////////////////////// + // Reads a FIT binary file. + // Parameters: + // file Pointer to file to read. + // mesgListener Message listener + // definitionListener Message definition listener + // descriptionListener Developer field description listener + // Returns true if finished read file, otherwise false if decoding is paused. + /////////////////////////////////////////////////////////////////////// + + + void Pause(void); + /////////////////////////////////////////////////////////////////////// + // Pauses the decoding of a FIT binary file. Call Resume() to resume decoding. + /////////////////////////////////////////////////////////////////////// + + FIT_BOOL Resume(void); + /////////////////////////////////////////////////////////////////////// + // Resumes the decoding of a FIT binary file (see Pause()). + // Returns true if finished reading file. + /////////////////////////////////////////////////////////////////////// + + FIT_BOOL getInvalidDataSize(void); + /////////////////////////////////////////////////////////////////////// + // Returns the invalid data size flag. + // This flag is set when the file size in the header is 0. + /////////////////////////////////////////////////////////////////////// + + void setInvalidDataSize(FIT_BOOL value); + /////////////////////////////////////////////////////////////////////// + // Set the invalid data size flag. + // Parameters: + // value The value to set the flag to. + /////////////////////////////////////////////////////////////////////// + +private: + typedef enum + { + STATE_FILE_HDR, + STATE_RECORD, + STATE_RESERVED1, + STATE_ARCH, + STATE_MESG_NUM_0, + STATE_MESG_NUM_1, + STATE_NUM_FIELDS, + STATE_FIELD_NUM, + STATE_FIELD_SIZE, + STATE_FIELD_TYPE, + STATE_NUM_DEV_FIELDS, + STATE_DEV_FIELD_NUM, + STATE_DEV_FIELD_SIZE, + STATE_DEV_FIELD_INDEX, + STATE_FIELD_DATA, + STATE_DEV_FIELD_DATA, + STATE_FILE_CRC_HIGH, + STATES + } STATE; + + typedef enum + { + RETURN_CONTINUE, + RETURN_MESG, + RETURN_MESG_DEF, + RETURN_END_OF_FILE, + RETURN_ERROR, + RETURNS + } RETURN; + + static const FIT_UINT8 DevFieldNumOffset; + static const FIT_UINT8 DevFieldSizeOffset; + static const FIT_UINT8 DevFieldIndexOffset; + static const FIT_UINT16 BufferSize = 512; + + STATE state; + FIT_BOOL hasDevData; + FIT_UINT8 fileHdrOffset; + FIT_UINT8 fileHdrSize; + FIT_UINT32 fileDataSize; + FIT_UINT32 fileBytesLeft; + FIT_UINT16 crc; + Mesg mesg; + FIT_UINT8 localMesgIndex; + MesgDefinition localMesgDefs[FIT_MAX_LOCAL_MESGS]; + FIT_UINT8 archs[FIT_MAX_LOCAL_MESGS]; + FIT_UINT8 numFields; + FIT_UINT8 fieldIndex; + FIT_UINT8 fieldDataIndex; + FIT_UINT8 fieldBytesLeft; + FIT_UINT8 fieldData[FIT_MAX_FIELD_SIZE]; + FIT_UINT8 lastTimeOffset; + FIT_UINT32 timestamp; + Accumulator accumulator; + std::istream* file; + MesgListener* mesgListener; + MesgDefinitionListener* mesgDefinitionListener; + DeveloperFieldDescriptionListener* descriptionListener; + FIT_BOOL pause; + std::string headerException; + FIT_BOOL skipHeader; + FIT_BOOL streamIsComplete; + FIT_BOOL invalidDataSize; + FIT_BOOL suppressComponentExpansion; + FIT_UINT32 currentByteOffset; + std::unordered_map developers; + std::unordered_map> descriptions; + FIT_UINT32 currentByteIndex; + FIT_UINT32 bytesRead; + char buffer[BufferSize]; + + + void InitRead(std::istream &file); + void InitRead(std::istream &file, FIT_BOOL startOfFile); + void UpdateEndianness(FIT_UINT8 type, FIT_UINT8 size); + RETURN ReadByte(FIT_UINT8 data); + void ExpandComponents(Field* containingField, const Profile::FIELD_COMPONENT* components, FIT_UINT16 numComponents); + FIT_BOOL Read(std::istream* file); +}; + +} // namespace fit + +#endif // defined(DECODE_HPP) + + diff --git a/fit_developer_data_id_mesg.hpp b/fit_developer_data_id_mesg.hpp new file mode 100644 index 0000000..6b2c85d --- /dev/null +++ b/fit_developer_data_id_mesg.hpp @@ -0,0 +1,218 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVELOPER_DATA_ID_MESG_HPP) +#define FIT_DEVELOPER_DATA_ID_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DeveloperDataIdMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 DeveloperId = 0; + static const FIT_UINT8 ApplicationId = 1; + static const FIT_UINT8 ManufacturerId = 2; + static const FIT_UINT8 DeveloperDataIndex = 3; + static const FIT_UINT8 ApplicationVersion = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DeveloperDataIdMesg(void) : Mesg(Profile::MESG_DEVELOPER_DATA_ID) + { + } + + DeveloperDataIdMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of developer_id + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumDeveloperId(void) const + { + return GetFieldNumValues(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of developer_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeveloperIdValid(FIT_UINT8 index) const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns developer_id field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetDeveloperId(FIT_UINT8 index) const + { + return GetFieldBYTEValue(0, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set developer_id field + /////////////////////////////////////////////////////////////////////// + void SetDeveloperId(FIT_UINT8 index, FIT_BYTE developerId) + { + SetFieldBYTEValue(0, developerId, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of application_id + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumApplicationId(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of application_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsApplicationIdValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns application_id field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetApplicationId(FIT_UINT8 index) const + { + return GetFieldBYTEValue(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set application_id field + /////////////////////////////////////////////////////////////////////// + void SetApplicationId(FIT_UINT8 index, FIT_BYTE applicationId) + { + SetFieldBYTEValue(1, applicationId, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerIdValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer_id field + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturerId(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer_id field + /////////////////////////////////////////////////////////////////////// + void SetManufacturerId(FIT_MANUFACTURER manufacturerId) + { + SetFieldUINT16Value(2, manufacturerId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of developer_data_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeveloperDataIndexValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns developer_data_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDeveloperDataIndex(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set developer_data_index field + /////////////////////////////////////////////////////////////////////// + void SetDeveloperDataIndex(FIT_UINT8 developerDataIndex) + { + SetFieldUINT8Value(3, developerDataIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of application_version field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsApplicationVersionValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns application_version field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetApplicationVersion(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set application_version field + /////////////////////////////////////////////////////////////////////// + void SetApplicationVersion(FIT_UINT32 applicationVersion) + { + SetFieldUINT32Value(4, applicationVersion, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DEVELOPER_DATA_ID_MESG_HPP) diff --git a/fit_developer_data_id_mesg_listener.hpp b/fit_developer_data_id_mesg_listener.hpp new file mode 100644 index 0000000..18da44a --- /dev/null +++ b/fit_developer_data_id_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVELOPER_DATA_ID_MESG_LISTENER_HPP) +#define FIT_DEVELOPER_DATA_ID_MESG_LISTENER_HPP + +#include "fit_developer_data_id_mesg.hpp" + +namespace fit +{ + +class DeveloperDataIdMesgListener +{ +public: + virtual ~DeveloperDataIdMesgListener() {} + virtual void OnMesg(DeveloperDataIdMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DEVELOPER_DATA_ID_MESG_LISTENER_HPP) diff --git a/fit_developer_field.cpp b/fit_developer_field.cpp new file mode 100644 index 0000000..b9c269e --- /dev/null +++ b/fit_developer_field.cpp @@ -0,0 +1,183 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_developer_field.hpp" +#include "fit_developer_field_definition.hpp" +#include "fit_unicode.hpp" + +namespace fit +{ +DeveloperField::DeveloperField(void) + : FieldBase() + , mDefinition(nullptr) +{ +} + +DeveloperField::DeveloperField(const DeveloperField& other) + : FieldBase(other) + , mDefinition(nullptr) +{ + if (nullptr != other.mDefinition) + { + mDefinition = new DeveloperFieldDefinition(*other.mDefinition); + } +} + +DeveloperField::DeveloperField(const DeveloperFieldDefinition& definition) + : FieldBase() + , mDefinition(new DeveloperFieldDefinition(definition)) +{ +} + +DeveloperField::DeveloperField(const FieldDescriptionMesg& definition, const DeveloperDataIdMesg& developer) + : FieldBase() + , mDefinition(new DeveloperFieldDefinition(definition, developer, 0)) +{ +} + +DeveloperField::~DeveloperField() +{ + if (nullptr != mDefinition) + { + delete mDefinition; + } +} + +FIT_BOOL DeveloperField::GetIsAccumulated() const +{ + return FIT_FALSE; +} + +FIT_BOOL DeveloperField::IsValid() const +{ + return nullptr != mDefinition; +} + +FIT_UINT8 DeveloperField::GetNum() const +{ + return mDefinition->GetNum(); +} + +std::string DeveloperField::GetName() const +{ + if (mDefinition->IsDefined()) + { + return Unicode::Encode_BaseToUTF8(mDefinition->GetDescription().GetFieldName(0)); + } + + return ""; +} + +FIT_UINT8 DeveloperField::GetType() const +{ + if (mDefinition->IsDefined()) + { + return mDefinition->GetType(); + } + + return FIT_BASE_TYPE_UINT8; +} + +std::string DeveloperField::GetUnits() const +{ + if (mDefinition->IsDefined()) + { + return Unicode::Encode_BaseToUTF8(mDefinition->GetDescription().GetUnits(0)); + } + + return ""; +} + +FIT_FLOAT64 DeveloperField::GetScale() const +{ + // Developer fields do not currently support scale + return 1.0; +} + +FIT_FLOAT64 DeveloperField::GetOffset() const +{ + // Developer fields do not currently support offset + return 0; +} + +const Profile::SUBFIELD* DeveloperField::GetSubField(const FIT_UINT16 subFieldIndex) const +{ + // Unused + (void)subFieldIndex; + return nullptr; +} + +FIT_UINT16 DeveloperField::GetNumSubFields() const +{ + return 0; +} + +const Profile::FIELD_COMPONENT* DeveloperField::GetComponent(const FIT_UINT16 component) const +{ + // Unused + (void)component; + return nullptr; +} + +FIT_UINT16 DeveloperField::GetNumComponents() const +{ + return 0; +} + +std::vector DeveloperField::GetAppId() const +{ + std::vector < FIT_BYTE > returnVal; + if ( mDefinition->IsDefined() ) + { + const DeveloperDataIdMesg& developer = mDefinition->GetDeveloper(); + returnVal.resize( developer.GetNumApplicationId() ); + for ( FIT_UINT8 i = 0; i < developer.GetNumApplicationId(); i++ ) + { + returnVal[i] = developer.GetApplicationId( i ); + } + } + + return returnVal; +} + +FIT_UINT32 DeveloperField::GetAppVersion() const +{ + if ( mDefinition->IsDefined() ) + { + const DeveloperDataIdMesg& developer = mDefinition->GetDeveloper(); + return developer.GetApplicationVersion(); + } + + return 0; +} + +FIT_UINT8 DeveloperField::GetNativeOverride() const +{ + if ( mDefinition->IsDefined() ) + { + const FieldDescriptionMesg& description = mDefinition->GetDescription(); + FIT_UINT8 nativeNum = description.GetNativeFieldNum(); + + if ( FIT_UINT8_INVALID != nativeNum ) + { + return nativeNum; + } + } + + return FIT_FIELD_NUM_INVALID; +} + +const DeveloperFieldDefinition& DeveloperField::GetDefinition() const +{ + return *mDefinition; +} +} // namespace fit diff --git a/fit_developer_field.hpp b/fit_developer_field.hpp new file mode 100644 index 0000000..3a82684 --- /dev/null +++ b/fit_developer_field.hpp @@ -0,0 +1,67 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(DEVELOPER_FIELD_HPP) +#define DEVELOPER_FIELD_HPP + +#include "fit_field_base.hpp" + +namespace fit +{ +class DeveloperDataIdMesg; +class FieldDescriptionMesg; +class DeveloperFieldDefinition; + +class DeveloperField + : public FieldBase +{ +public: + DeveloperField(void); + DeveloperField(const DeveloperField &field); + DeveloperField(const FieldDescriptionMesg& definition, const DeveloperDataIdMesg& developer); + explicit DeveloperField(const DeveloperFieldDefinition& definition); + virtual ~DeveloperField(); + + virtual FIT_BOOL GetIsAccumulated() const override; + virtual FIT_BOOL IsValid(void) const override; + virtual FIT_UINT8 GetNum(void) const override; + virtual std::string GetName() const override; + virtual FIT_UINT8 GetType() const override; + virtual std::string GetUnits() const override; + virtual FIT_FLOAT64 GetScale() const override; + virtual FIT_FLOAT64 GetOffset() const override; + virtual const Profile::SUBFIELD* GetSubField(const FIT_UINT16 subFieldIndex) const override; + virtual FIT_UINT16 GetNumSubFields(void) const override; + virtual const Profile::FIELD_COMPONENT* GetComponent(const FIT_UINT16 component) const override; + virtual FIT_UINT16 GetNumComponents(void) const override; + + std::vector GetAppId() const; + FIT_UINT32 GetAppVersion() const; + FIT_UINT8 GetNativeOverride() const; + + const DeveloperFieldDefinition& GetDefinition() const; + + // Unhide the overloaded get methods from FieldBase. + using FieldBase::GetName; + using FieldBase::GetType; + using FieldBase::GetUnits; + using FieldBase::GetScale; + using FieldBase::GetOffset; + +private: + DeveloperFieldDefinition* mDefinition; + +}; + +} // namespace fit + +#endif // defined(DEVELOPER_FIELD_HPP) diff --git a/fit_developer_field_definition.cpp b/fit_developer_field_definition.cpp new file mode 100644 index 0000000..b9d712d --- /dev/null +++ b/fit_developer_field_definition.cpp @@ -0,0 +1,182 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include "fit_developer_field_definition.hpp" +#include "fit_developer_field.hpp" + +namespace fit +{ + +DeveloperFieldDefinition::DeveloperFieldDefinition() + : num( FIT_FIELD_NUM_INVALID ) + , size( 0 ) + , developerDataIndex( FIT_UINT8_INVALID ) + , mesg( nullptr ) + , developer( nullptr ) +{ +} + +DeveloperFieldDefinition::DeveloperFieldDefinition(const DeveloperFieldDefinition& other) + : num( other.num ) + , size( other.size ) + , developerDataIndex( other.developerDataIndex ) + , mesg( nullptr ) + , developer( nullptr ) +{ + if (nullptr != other.mesg) + { + mesg = new FieldDescriptionMesg( *other.mesg ); + } + + if ( nullptr != other.developer ) + { + developer = new DeveloperDataIdMesg( *other.developer ); + } +} + +DeveloperFieldDefinition::DeveloperFieldDefinition(FIT_UINT8 fieldNum, FIT_UINT8 size, FIT_UINT8 developerDataIndex) + : num( fieldNum ) + , size( size ) + , developerDataIndex( developerDataIndex ) + , mesg( nullptr ) + , developer( nullptr ) +{ +} + +DeveloperFieldDefinition::DeveloperFieldDefinition( const FieldDescriptionMesg& desc, const DeveloperDataIdMesg& developer, FIT_UINT8 size ) + : num( desc.GetFieldDefinitionNumber() ) + , size( size ) + , developerDataIndex( desc.GetDeveloperDataIndex() ) + , mesg( new FieldDescriptionMesg( desc ) ) + , developer( new DeveloperDataIdMesg( developer ) ) +{ +} + +DeveloperFieldDefinition::DeveloperFieldDefinition(const DeveloperField& field) + : DeveloperFieldDefinition(field.GetDefinition()) +{ + size = field.GetSize(); +} + +DeveloperFieldDefinition::~DeveloperFieldDefinition() +{ + if ( nullptr != mesg ) + { + delete mesg; + mesg = nullptr; + } + + if ( nullptr != developer ) + { + delete developer; + developer = nullptr; + } +} + +FIT_BOOL DeveloperFieldDefinition::IsDefined() const +{ + return nullptr != mesg && + nullptr != developer; +} + +FIT_UINT8 DeveloperFieldDefinition::GetNum() const +{ + return num; +} + +FIT_UINT8 DeveloperFieldDefinition::GetSize() const +{ + return size; +} + +FIT_UINT8 DeveloperFieldDefinition::GetType() const +{ + if (IsDefined()) + { + return mesg->GetFitBaseTypeId(); + } + + return FIT_BASE_TYPE_UINT8; +} + +FIT_UINT8 DeveloperFieldDefinition::GetDeveloperDataIndex() const +{ + return developerDataIndex; +} + +const FieldDescriptionMesg& DeveloperFieldDefinition::GetDescription() const +{ + return *mesg; +} + +const DeveloperDataIdMesg& DeveloperFieldDefinition::GetDeveloper() const +{ + return *developer; +} + +FIT_BOOL DeveloperFieldDefinition::operator==(const DeveloperFieldDefinition& field) const +{ + if (num != field.num) + return FIT_FALSE; + + if (developerDataIndex != field.developerDataIndex) + return FIT_FALSE; + + return FIT_TRUE; +} + +FIT_BOOL DeveloperFieldDefinition::operator!=(const DeveloperFieldDefinition& field) const +{ + return !(*this == field); +} + +FIT_UINT8 DeveloperFieldDefinition::Write(std::ostream &file) const +{ + file.put(num); + file.put(size); + file.put(developerDataIndex); + + return 3; +} + +DeveloperFieldDefinition& DeveloperFieldDefinition::operator=(const DeveloperFieldDefinition& other) +{ + if (this != &other) + { + num = other.num; + size = other.size; + developerDataIndex = other.developerDataIndex; + + if (other.mesg != nullptr) + { + if (mesg != nullptr) + { + delete mesg; + } + mesg = new FieldDescriptionMesg(*other.mesg); + } + + if (other.developer != nullptr) + { + if(developer != nullptr) + { + delete developer; + }; + developer = new DeveloperDataIdMesg(*other.developer); + } + } + + return *this; +} + +} // namespace fit diff --git a/fit_developer_field_definition.hpp b/fit_developer_field_definition.hpp new file mode 100644 index 0000000..ffbf79e --- /dev/null +++ b/fit_developer_field_definition.hpp @@ -0,0 +1,59 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVELOPER_FIELD_DEFINITION_HPP) +#define FIT_DEVELOPER_FIELD_DEFINITION_HPP + +#include +#include "fit.hpp" +#include "fit_field_description_mesg.hpp" +#include "fit_developer_data_id_mesg.hpp" + +namespace fit +{ +class DeveloperField; + +class DeveloperFieldDefinition +{ +public: + DeveloperFieldDefinition(); + DeveloperFieldDefinition(const DeveloperFieldDefinition& other); + DeveloperFieldDefinition(FIT_UINT8 fieldNum, FIT_UINT8 size, FIT_UINT8 developerDataIndex); + DeveloperFieldDefinition(const FieldDescriptionMesg& desc, const DeveloperDataIdMesg& developer, FIT_UINT8 size); + explicit DeveloperFieldDefinition(const DeveloperField& field); + virtual ~DeveloperFieldDefinition(); + + FIT_BOOL IsDefined() const; + FIT_UINT8 GetNum() const; + FIT_UINT8 GetSize() const; + FIT_UINT8 GetType() const; + FIT_UINT8 GetDeveloperDataIndex() const; + const FieldDescriptionMesg& GetDescription() const; + const DeveloperDataIdMesg& GetDeveloper() const; + + FIT_BOOL operator==(const DeveloperFieldDefinition& field) const; + FIT_BOOL operator!=(const DeveloperFieldDefinition& field) const; + DeveloperFieldDefinition& operator=(const DeveloperFieldDefinition& other); + FIT_UINT8 Write(std::ostream &file) const; + +private: + FIT_UINT8 num; + FIT_UINT8 size; + FIT_UINT8 developerDataIndex; + + FieldDescriptionMesg* mesg; + DeveloperDataIdMesg* developer; +}; + +} // namespace fit + +#endif // defined(FIT_FIELD_DEFINITION_HPP) diff --git a/fit_developer_field_description.cpp b/fit_developer_field_description.cpp new file mode 100644 index 0000000..3f3ffa4 --- /dev/null +++ b/fit_developer_field_description.cpp @@ -0,0 +1,69 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_developer_field_description.hpp" + +namespace fit +{ +DeveloperFieldDescription::DeveloperFieldDescription + ( + const DeveloperFieldDescription& other + ) + : description( new FieldDescriptionMesg( *other.description ) ) + , developer( new DeveloperDataIdMesg( *other.developer ) ) +{ + +} + +DeveloperFieldDescription::DeveloperFieldDescription + ( + const FieldDescriptionMesg& desc, + const DeveloperDataIdMesg& developer + ) + : description( new FieldDescriptionMesg( desc ) ) + , developer( new DeveloperDataIdMesg( developer ) ) +{ +} + +DeveloperFieldDescription::~DeveloperFieldDescription() +{ + delete developer; + delete description; +} + +FIT_UINT32 DeveloperFieldDescription::GetApplicationVersion() const +{ + return developer->GetApplicationVersion(); +} + +FIT_UINT8 DeveloperFieldDescription::GetFieldDefinitionNumber() const +{ + return description->GetFieldDefinitionNumber(); +} + +std::vector DeveloperFieldDescription::GetApplicationId() const +{ + // This is a UUID, and thus we expect the return value to be exactly 16 bytes. + // if it is not we will return an empty vector + std::vector< FIT_UINT8 > rv( 16 ); + + if ( developer->GetNumApplicationId() == 16 ) + { + for ( FIT_UINT8 i = 0; i < 16; i++ ) + { + rv[i] = developer->GetApplicationId( i ); + } + } + + return rv; +} +} // namespace fit diff --git a/fit_developer_field_description.hpp b/fit_developer_field_description.hpp new file mode 100644 index 0000000..c9fe3ce --- /dev/null +++ b/fit_developer_field_description.hpp @@ -0,0 +1,41 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVELOPER_FIELD_DESCRIPTION_HPP) +#define FIT_DEVELOPER_FIELD_DESCRIPTION_HPP + +#include "fit_field_description_mesg.hpp" +#include "fit_developer_data_id_mesg.hpp" +#include + +namespace fit +{ +class DeveloperFieldDescription +{ +public: + DeveloperFieldDescription() = delete; + DeveloperFieldDescription(const DeveloperFieldDescription& other); + DeveloperFieldDescription(const FieldDescriptionMesg& desc, const DeveloperDataIdMesg& developer); + virtual ~DeveloperFieldDescription(); + + FIT_UINT32 GetApplicationVersion() const; + FIT_UINT8 GetFieldDefinitionNumber() const; + std::vector GetApplicationId() const; + +private: + FieldDescriptionMesg* description; + DeveloperDataIdMesg* developer; +}; + +} // namespace fit + +#endif // defined(FIT_FIELD_DEFINITION_HPP) diff --git a/fit_developer_field_description_listener.hpp b/fit_developer_field_description_listener.hpp new file mode 100644 index 0000000..1c74566 --- /dev/null +++ b/fit_developer_field_description_listener.hpp @@ -0,0 +1,31 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVELOPER_FIELD_DESCRIPTION_LISTENER_HPP) +#define FIT_DEVELOPER_FIELD_DESCRIPTION_LISTENER_HPP + +#include "fit_developer_field_description.hpp" + +namespace fit +{ +class DeveloperFieldDescription; + +class DeveloperFieldDescriptionListener +{ +public: + virtual ~DeveloperFieldDescriptionListener() {}; + virtual void OnDeveloperFieldDescription( const DeveloperFieldDescription& desc ) = 0; +}; + +} // namespace fit + +#endif // FIT_DEVELOPER_FIELD_DESCRIPTION_LISTENER_HPP diff --git a/fit_device_aux_battery_info_mesg.hpp b/fit_device_aux_battery_info_mesg.hpp new file mode 100644 index 0000000..d965a3e --- /dev/null +++ b/fit_device_aux_battery_info_mesg.hpp @@ -0,0 +1,204 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVICE_AUX_BATTERY_INFO_MESG_HPP) +#define FIT_DEVICE_AUX_BATTERY_INFO_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DeviceAuxBatteryInfoMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 DeviceIndex = 0; + static const FIT_UINT8 BatteryVoltage = 1; + static const FIT_UINT8 BatteryStatus = 2; + static const FIT_UINT8 BatteryIdentifier = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DeviceAuxBatteryInfoMesg(void) : Mesg(Profile::MESG_DEVICE_AUX_BATTERY_INFO) + { + } + + DeviceAuxBatteryInfoMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_index field + /////////////////////////////////////////////////////////////////////// + FIT_DEVICE_INDEX GetDeviceIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_index field + /////////////////////////////////////////////////////////////////////// + void SetDeviceIndex(FIT_DEVICE_INDEX deviceIndex) + { + SetFieldUINT8Value(0, deviceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_voltage field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryVoltageValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_voltage field + // Units: V + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBatteryVoltage(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_voltage field + // Units: V + /////////////////////////////////////////////////////////////////////// + void SetBatteryVoltage(FIT_FLOAT32 batteryVoltage) + { + SetFieldFLOAT32Value(1, batteryVoltage, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryStatusValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_status field + /////////////////////////////////////////////////////////////////////// + FIT_BATTERY_STATUS GetBatteryStatus(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_status field + /////////////////////////////////////////////////////////////////////// + void SetBatteryStatus(FIT_BATTERY_STATUS batteryStatus) + { + SetFieldUINT8Value(2, batteryStatus, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_identifier field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryIdentifierValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_identifier field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetBatteryIdentifier(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_identifier field + /////////////////////////////////////////////////////////////////////// + void SetBatteryIdentifier(FIT_UINT8 batteryIdentifier) + { + SetFieldUINT8Value(3, batteryIdentifier, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DEVICE_AUX_BATTERY_INFO_MESG_HPP) diff --git a/fit_device_aux_battery_info_mesg_listener.hpp b/fit_device_aux_battery_info_mesg_listener.hpp new file mode 100644 index 0000000..5faa265 --- /dev/null +++ b/fit_device_aux_battery_info_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVICE_AUX_BATTERY_INFO_MESG_LISTENER_HPP) +#define FIT_DEVICE_AUX_BATTERY_INFO_MESG_LISTENER_HPP + +#include "fit_device_aux_battery_info_mesg.hpp" + +namespace fit +{ + +class DeviceAuxBatteryInfoMesgListener +{ +public: + virtual ~DeviceAuxBatteryInfoMesgListener() {} + virtual void OnMesg(DeviceAuxBatteryInfoMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DEVICE_AUX_BATTERY_INFO_MESG_LISTENER_HPP) diff --git a/fit_device_info_mesg.hpp b/fit_device_info_mesg.hpp new file mode 100644 index 0000000..39ed9cb --- /dev/null +++ b/fit_device_info_mesg.hpp @@ -0,0 +1,888 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVICE_INFO_MESG_HPP) +#define FIT_DEVICE_INFO_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DeviceInfoMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 DeviceIndex = 0; + static const FIT_UINT8 DeviceType = 1; + static const FIT_UINT8 Manufacturer = 2; + static const FIT_UINT8 SerialNumber = 3; + static const FIT_UINT8 Product = 4; + static const FIT_UINT8 SoftwareVersion = 5; + static const FIT_UINT8 HardwareVersion = 6; + static const FIT_UINT8 CumOperatingTime = 7; + static const FIT_UINT8 BatteryVoltage = 10; + static const FIT_UINT8 BatteryStatus = 11; + static const FIT_UINT8 SensorPosition = 18; + static const FIT_UINT8 Descriptor = 19; + static const FIT_UINT8 AntTransmissionType = 20; + static const FIT_UINT8 AntDeviceNumber = 21; + static const FIT_UINT8 AntNetwork = 22; + static const FIT_UINT8 SourceType = 25; + static const FIT_UINT8 ProductName = 27; + static const FIT_UINT8 BatteryLevel = 32; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DeviceInfoMesg(void) : Mesg(Profile::MESG_DEVICE_INFO) + { + } + + DeviceInfoMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_index field + /////////////////////////////////////////////////////////////////////// + FIT_DEVICE_INDEX GetDeviceIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_index field + /////////////////////////////////////////////////////////////////////// + void SetDeviceIndex(FIT_DEVICE_INDEX deviceIndex) + { + SetFieldUINT8Value(0, deviceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDeviceType(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_type field + /////////////////////////////////////////////////////////////////////// + void SetDeviceType(FIT_UINT8 deviceType) + { + SetFieldUINT8Value(1, deviceType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ble_device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBleDeviceTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_BLE_DEVICE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_BLE_DEVICE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns ble_device_type field + /////////////////////////////////////////////////////////////////////// + FIT_BLE_DEVICE_TYPE GetBleDeviceType(void) const + { + return GetFieldUINT8Value(1, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_BLE_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set ble_device_type field + /////////////////////////////////////////////////////////////////////// + void SetBleDeviceType(FIT_BLE_DEVICE_TYPE bleDeviceType) + { + SetFieldUINT8Value(1, bleDeviceType, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_BLE_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of antplus_device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAntplusDeviceTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANTPLUS_DEVICE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANTPLUS_DEVICE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns antplus_device_type field + /////////////////////////////////////////////////////////////////////// + FIT_ANTPLUS_DEVICE_TYPE GetAntplusDeviceType(void) const + { + return GetFieldUINT8Value(1, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANTPLUS_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set antplus_device_type field + /////////////////////////////////////////////////////////////////////// + void SetAntplusDeviceType(FIT_ANTPLUS_DEVICE_TYPE antplusDeviceType) + { + SetFieldUINT8Value(1, antplusDeviceType, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANTPLUS_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ant_device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAntDeviceTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANT_DEVICE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANT_DEVICE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns ant_device_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAntDeviceType(void) const + { + return GetFieldUINT8Value(1, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANT_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set ant_device_type field + /////////////////////////////////////////////////////////////////////// + void SetAntDeviceType(FIT_UINT8 antDeviceType) + { + SetFieldUINT8Value(1, antDeviceType, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANT_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalDeviceTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_LOCAL_DEVICE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_LOCAL_DEVICE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns local_device_type field + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DEVICE_TYPE GetLocalDeviceType(void) const + { + return GetFieldUINT8Value(1, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_LOCAL_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_device_type field + /////////////////////////////////////////////////////////////////////// + void SetLocalDeviceType(FIT_LOCAL_DEVICE_TYPE localDeviceType) + { + SetFieldUINT8Value(1, localDeviceType, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_LOCAL_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer field + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturer(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer field + /////////////////////////////////////////////////////////////////////// + void SetManufacturer(FIT_MANUFACTURER manufacturer) + { + SetFieldUINT16Value(2, manufacturer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of serial_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSerialNumberValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns serial_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32Z GetSerialNumber(void) const + { + return GetFieldUINT32ZValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set serial_number field + /////////////////////////////////////////////////////////////////////// + void SetSerialNumber(FIT_UINT32Z serialNumber) + { + SetFieldUINT32ZValue(3, serialNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProduct(void) const + { + return GetFieldUINT16Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product field + /////////////////////////////////////////////////////////////////////// + void SetProduct(FIT_UINT16 product) + { + SetFieldUINT16Value(4, product, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of favero_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFaveroProductValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_FAVERO_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns favero_product field + /////////////////////////////////////////////////////////////////////// + FIT_FAVERO_PRODUCT GetFaveroProduct(void) const + { + return GetFieldUINT16Value(4, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set favero_product field + /////////////////////////////////////////////////////////////////////// + void SetFaveroProduct(FIT_FAVERO_PRODUCT faveroProduct) + { + SetFieldUINT16Value(4, faveroProduct, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of garmin_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGarminProductValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_GARMIN_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns garmin_product field + /////////////////////////////////////////////////////////////////////// + FIT_GARMIN_PRODUCT GetGarminProduct(void) const + { + return GetFieldUINT16Value(4, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set garmin_product field + /////////////////////////////////////////////////////////////////////// + void SetGarminProduct(FIT_GARMIN_PRODUCT garminProduct) + { + SetFieldUINT16Value(4, garminProduct, 0, (FIT_UINT16) Profile::DEVICE_INFO_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of software_version field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSoftwareVersionValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns software_version field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSoftwareVersion(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set software_version field + /////////////////////////////////////////////////////////////////////// + void SetSoftwareVersion(FIT_FLOAT32 softwareVersion) + { + SetFieldFLOAT32Value(5, softwareVersion, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hardware_version field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHardwareVersionValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hardware_version field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHardwareVersion(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hardware_version field + /////////////////////////////////////////////////////////////////////// + void SetHardwareVersion(FIT_UINT8 hardwareVersion) + { + SetFieldUINT8Value(6, hardwareVersion, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cum_operating_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCumOperatingTimeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cum_operating_time field + // Units: s + // Comment: Reset by new battery or charge. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCumOperatingTime(void) const + { + return GetFieldUINT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cum_operating_time field + // Units: s + // Comment: Reset by new battery or charge. + /////////////////////////////////////////////////////////////////////// + void SetCumOperatingTime(FIT_UINT32 cumOperatingTime) + { + SetFieldUINT32Value(7, cumOperatingTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_voltage field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryVoltageValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_voltage field + // Units: V + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBatteryVoltage(void) const + { + return GetFieldFLOAT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_voltage field + // Units: V + /////////////////////////////////////////////////////////////////////// + void SetBatteryVoltage(FIT_FLOAT32 batteryVoltage) + { + SetFieldFLOAT32Value(10, batteryVoltage, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryStatusValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_status field + /////////////////////////////////////////////////////////////////////// + FIT_BATTERY_STATUS GetBatteryStatus(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_status field + /////////////////////////////////////////////////////////////////////// + void SetBatteryStatus(FIT_BATTERY_STATUS batteryStatus) + { + SetFieldUINT8Value(11, batteryStatus, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sensor_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSensorPositionValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sensor_position field + // Comment: Indicates the location of the sensor + /////////////////////////////////////////////////////////////////////// + FIT_BODY_LOCATION GetSensorPosition(void) const + { + return GetFieldENUMValue(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sensor_position field + // Comment: Indicates the location of the sensor + /////////////////////////////////////////////////////////////////////// + void SetSensorPosition(FIT_BODY_LOCATION sensorPosition) + { + SetFieldENUMValue(18, sensorPosition, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of descriptor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDescriptorValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns descriptor field + // Comment: Used to describe the sensor or location + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetDescriptor(void) const + { + return GetFieldSTRINGValue(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set descriptor field + // Comment: Used to describe the sensor or location + /////////////////////////////////////////////////////////////////////// + void SetDescriptor(FIT_WSTRING descriptor) + { + SetFieldSTRINGValue(19, descriptor, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ant_transmission_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAntTransmissionTypeValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ant_transmission_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetAntTransmissionType(void) const + { + return GetFieldUINT8ZValue(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ant_transmission_type field + /////////////////////////////////////////////////////////////////////// + void SetAntTransmissionType(FIT_UINT8Z antTransmissionType) + { + SetFieldUINT8ZValue(20, antTransmissionType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ant_device_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAntDeviceNumberValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ant_device_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetAntDeviceNumber(void) const + { + return GetFieldUINT16ZValue(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ant_device_number field + /////////////////////////////////////////////////////////////////////// + void SetAntDeviceNumber(FIT_UINT16Z antDeviceNumber) + { + SetFieldUINT16ZValue(21, antDeviceNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ant_network field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAntNetworkValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ant_network field + /////////////////////////////////////////////////////////////////////// + FIT_ANT_NETWORK GetAntNetwork(void) const + { + return GetFieldENUMValue(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ant_network field + /////////////////////////////////////////////////////////////////////// + void SetAntNetwork(FIT_ANT_NETWORK antNetwork) + { + SetFieldENUMValue(22, antNetwork, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of source_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSourceTypeValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns source_type field + /////////////////////////////////////////////////////////////////////// + FIT_SOURCE_TYPE GetSourceType(void) const + { + return GetFieldENUMValue(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set source_type field + /////////////////////////////////////////////////////////////////////// + void SetSourceType(FIT_SOURCE_TYPE sourceType) + { + SetFieldENUMValue(25, sourceType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductNameValid() const + { + const Field* field = GetField(27); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product_name field + // Comment: Optional free form string to indicate the devices name or model + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetProductName(void) const + { + return GetFieldSTRINGValue(27, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product_name field + // Comment: Optional free form string to indicate the devices name or model + /////////////////////////////////////////////////////////////////////// + void SetProductName(FIT_WSTRING productName) + { + SetFieldSTRINGValue(27, productName, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryLevelValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_level field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetBatteryLevel(void) const + { + return GetFieldUINT8Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_level field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetBatteryLevel(FIT_UINT8 batteryLevel) + { + SetFieldUINT8Value(32, batteryLevel, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DEVICE_INFO_MESG_HPP) diff --git a/fit_device_info_mesg_listener.hpp b/fit_device_info_mesg_listener.hpp new file mode 100644 index 0000000..39cf614 --- /dev/null +++ b/fit_device_info_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVICE_INFO_MESG_LISTENER_HPP) +#define FIT_DEVICE_INFO_MESG_LISTENER_HPP + +#include "fit_device_info_mesg.hpp" + +namespace fit +{ + +class DeviceInfoMesgListener +{ +public: + virtual ~DeviceInfoMesgListener() {} + virtual void OnMesg(DeviceInfoMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DEVICE_INFO_MESG_LISTENER_HPP) diff --git a/fit_device_settings_mesg.hpp b/fit_device_settings_mesg.hpp new file mode 100644 index 0000000..064791f --- /dev/null +++ b/fit_device_settings_mesg.hpp @@ -0,0 +1,900 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVICE_SETTINGS_MESG_HPP) +#define FIT_DEVICE_SETTINGS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DeviceSettingsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 ActiveTimeZone = 0; + static const FIT_UINT8 UtcOffset = 1; + static const FIT_UINT8 TimeOffset = 2; + static const FIT_UINT8 TimeMode = 4; + static const FIT_UINT8 TimeZoneOffset = 5; + static const FIT_UINT8 BacklightMode = 12; + static const FIT_UINT8 ActivityTrackerEnabled = 36; + static const FIT_UINT8 ClockTime = 39; + static const FIT_UINT8 PagesEnabled = 40; + static const FIT_UINT8 MoveAlertEnabled = 46; + static const FIT_UINT8 DateMode = 47; + static const FIT_UINT8 DisplayOrientation = 55; + static const FIT_UINT8 MountingSide = 56; + static const FIT_UINT8 DefaultPage = 57; + static const FIT_UINT8 AutosyncMinSteps = 58; + static const FIT_UINT8 AutosyncMinTime = 59; + static const FIT_UINT8 LactateThresholdAutodetectEnabled = 80; + static const FIT_UINT8 BleAutoUploadEnabled = 86; + static const FIT_UINT8 AutoSyncFrequency = 89; + static const FIT_UINT8 AutoActivityDetect = 90; + static const FIT_UINT8 NumberOfScreens = 94; + static const FIT_UINT8 SmartNotificationDisplayOrientation = 95; + static const FIT_UINT8 TapInterface = 134; + static const FIT_UINT8 TapSensitivity = 174; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DeviceSettingsMesg(void) : Mesg(Profile::MESG_DEVICE_SETTINGS) + { + } + + DeviceSettingsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_time_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveTimeZoneValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_time_zone field + // Comment: Index into time zone arrays. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetActiveTimeZone(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_time_zone field + // Comment: Index into time zone arrays. + /////////////////////////////////////////////////////////////////////// + void SetActiveTimeZone(FIT_UINT8 activeTimeZone) + { + SetFieldUINT8Value(0, activeTimeZone, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of utc_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUtcOffsetValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns utc_offset field + // Comment: Offset from system time. Required to convert timestamp from system time to UTC. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetUtcOffset(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set utc_offset field + // Comment: Offset from system time. Required to convert timestamp from system time to UTC. + /////////////////////////////////////////////////////////////////////// + void SetUtcOffset(FIT_UINT32 utcOffset) + { + SetFieldUINT32Value(1, utcOffset, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeOffset(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_offset field + // Units: s + // Comment: Offset from system time. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTimeOffset(FIT_UINT8 index) const + { + return GetFieldUINT32Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_offset field + // Units: s + // Comment: Offset from system time. + /////////////////////////////////////////////////////////////////////// + void SetTimeOffset(FIT_UINT8 index, FIT_UINT32 timeOffset) + { + SetFieldUINT32Value(2, timeOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_mode + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeMode(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeModeValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_mode field + // Comment: Display mode for the time + /////////////////////////////////////////////////////////////////////// + FIT_TIME_MODE GetTimeMode(FIT_UINT8 index) const + { + return GetFieldENUMValue(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_mode field + // Comment: Display mode for the time + /////////////////////////////////////////////////////////////////////// + void SetTimeMode(FIT_UINT8 index, FIT_TIME_MODE timeMode) + { + SetFieldENUMValue(4, timeMode, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_zone_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeZoneOffset(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_zone_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeZoneOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_zone_offset field + // Units: hr + // Comment: timezone offset in 1/4 hour increments + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeZoneOffset(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_zone_offset field + // Units: hr + // Comment: timezone offset in 1/4 hour increments + /////////////////////////////////////////////////////////////////////// + void SetTimeZoneOffset(FIT_UINT8 index, FIT_FLOAT32 timeZoneOffset) + { + SetFieldFLOAT32Value(5, timeZoneOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of backlight_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBacklightModeValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns backlight_mode field + // Comment: Mode for backlight + /////////////////////////////////////////////////////////////////////// + FIT_BACKLIGHT_MODE GetBacklightMode(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set backlight_mode field + // Comment: Mode for backlight + /////////////////////////////////////////////////////////////////////// + void SetBacklightMode(FIT_BACKLIGHT_MODE backlightMode) + { + SetFieldENUMValue(12, backlightMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_tracker_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityTrackerEnabledValid() const + { + const Field* field = GetField(36); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_tracker_enabled field + // Comment: Enabled state of the activity tracker functionality + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetActivityTrackerEnabled(void) const + { + return GetFieldENUMValue(36, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_tracker_enabled field + // Comment: Enabled state of the activity tracker functionality + /////////////////////////////////////////////////////////////////////// + void SetActivityTrackerEnabled(FIT_BOOL activityTrackerEnabled) + { + SetFieldENUMValue(36, activityTrackerEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of clock_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClockTimeValid() const + { + const Field* field = GetField(39); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns clock_time field + // Comment: UTC timestamp used to set the devices clock and date + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetClockTime(void) const + { + return GetFieldUINT32Value(39, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set clock_time field + // Comment: UTC timestamp used to set the devices clock and date + /////////////////////////////////////////////////////////////////////// + void SetClockTime(FIT_DATE_TIME clockTime) + { + SetFieldUINT32Value(39, clockTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of pages_enabled + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumPagesEnabled(void) const + { + return GetFieldNumValues(40, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pages_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPagesEnabledValid(FIT_UINT8 index) const + { + const Field* field = GetField(40); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pages_enabled field + // Comment: Bitfield to configure enabled screens for each supported loop + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPagesEnabled(FIT_UINT8 index) const + { + return GetFieldUINT16Value(40, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pages_enabled field + // Comment: Bitfield to configure enabled screens for each supported loop + /////////////////////////////////////////////////////////////////////// + void SetPagesEnabled(FIT_UINT8 index, FIT_UINT16 pagesEnabled) + { + SetFieldUINT16Value(40, pagesEnabled, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of move_alert_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMoveAlertEnabledValid() const + { + const Field* field = GetField(46); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns move_alert_enabled field + // Comment: Enabled state of the move alert + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetMoveAlertEnabled(void) const + { + return GetFieldENUMValue(46, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set move_alert_enabled field + // Comment: Enabled state of the move alert + /////////////////////////////////////////////////////////////////////// + void SetMoveAlertEnabled(FIT_BOOL moveAlertEnabled) + { + SetFieldENUMValue(46, moveAlertEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of date_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDateModeValid() const + { + const Field* field = GetField(47); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns date_mode field + // Comment: Display mode for the date + /////////////////////////////////////////////////////////////////////// + FIT_DATE_MODE GetDateMode(void) const + { + return GetFieldENUMValue(47, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set date_mode field + // Comment: Display mode for the date + /////////////////////////////////////////////////////////////////////// + void SetDateMode(FIT_DATE_MODE dateMode) + { + SetFieldENUMValue(47, dateMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of display_orientation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDisplayOrientationValid() const + { + const Field* field = GetField(55); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns display_orientation field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_ORIENTATION GetDisplayOrientation(void) const + { + return GetFieldENUMValue(55, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set display_orientation field + /////////////////////////////////////////////////////////////////////// + void SetDisplayOrientation(FIT_DISPLAY_ORIENTATION displayOrientation) + { + SetFieldENUMValue(55, displayOrientation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mounting_side field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMountingSideValid() const + { + const Field* field = GetField(56); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mounting_side field + /////////////////////////////////////////////////////////////////////// + FIT_SIDE GetMountingSide(void) const + { + return GetFieldENUMValue(56, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mounting_side field + /////////////////////////////////////////////////////////////////////// + void SetMountingSide(FIT_SIDE mountingSide) + { + SetFieldENUMValue(56, mountingSide, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of default_page + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumDefaultPage(void) const + { + return GetFieldNumValues(57, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of default_page field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDefaultPageValid(FIT_UINT8 index) const + { + const Field* field = GetField(57); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns default_page field + // Comment: Bitfield to indicate one page as default for each supported loop + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetDefaultPage(FIT_UINT8 index) const + { + return GetFieldUINT16Value(57, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set default_page field + // Comment: Bitfield to indicate one page as default for each supported loop + /////////////////////////////////////////////////////////////////////// + void SetDefaultPage(FIT_UINT8 index, FIT_UINT16 defaultPage) + { + SetFieldUINT16Value(57, defaultPage, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of autosync_min_steps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutosyncMinStepsValid() const + { + const Field* field = GetField(58); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns autosync_min_steps field + // Units: steps + // Comment: Minimum steps before an autosync can occur + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAutosyncMinSteps(void) const + { + return GetFieldUINT16Value(58, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set autosync_min_steps field + // Units: steps + // Comment: Minimum steps before an autosync can occur + /////////////////////////////////////////////////////////////////////// + void SetAutosyncMinSteps(FIT_UINT16 autosyncMinSteps) + { + SetFieldUINT16Value(58, autosyncMinSteps, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of autosync_min_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutosyncMinTimeValid() const + { + const Field* field = GetField(59); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns autosync_min_time field + // Units: minutes + // Comment: Minimum minutes before an autosync can occur + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAutosyncMinTime(void) const + { + return GetFieldUINT16Value(59, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set autosync_min_time field + // Units: minutes + // Comment: Minimum minutes before an autosync can occur + /////////////////////////////////////////////////////////////////////// + void SetAutosyncMinTime(FIT_UINT16 autosyncMinTime) + { + SetFieldUINT16Value(59, autosyncMinTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of lactate_threshold_autodetect_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLactateThresholdAutodetectEnabledValid() const + { + const Field* field = GetField(80); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns lactate_threshold_autodetect_enabled field + // Comment: Enable auto-detect setting for the lactate threshold feature. + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetLactateThresholdAutodetectEnabled(void) const + { + return GetFieldENUMValue(80, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set lactate_threshold_autodetect_enabled field + // Comment: Enable auto-detect setting for the lactate threshold feature. + /////////////////////////////////////////////////////////////////////// + void SetLactateThresholdAutodetectEnabled(FIT_BOOL lactateThresholdAutodetectEnabled) + { + SetFieldENUMValue(80, lactateThresholdAutodetectEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ble_auto_upload_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBleAutoUploadEnabledValid() const + { + const Field* field = GetField(86); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ble_auto_upload_enabled field + // Comment: Automatically upload using BLE + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetBleAutoUploadEnabled(void) const + { + return GetFieldENUMValue(86, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ble_auto_upload_enabled field + // Comment: Automatically upload using BLE + /////////////////////////////////////////////////////////////////////// + void SetBleAutoUploadEnabled(FIT_BOOL bleAutoUploadEnabled) + { + SetFieldENUMValue(86, bleAutoUploadEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_sync_frequency field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoSyncFrequencyValid() const + { + const Field* field = GetField(89); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns auto_sync_frequency field + // Comment: Helps to conserve battery by changing modes + /////////////////////////////////////////////////////////////////////// + FIT_AUTO_SYNC_FREQUENCY GetAutoSyncFrequency(void) const + { + return GetFieldENUMValue(89, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_sync_frequency field + // Comment: Helps to conserve battery by changing modes + /////////////////////////////////////////////////////////////////////// + void SetAutoSyncFrequency(FIT_AUTO_SYNC_FREQUENCY autoSyncFrequency) + { + SetFieldENUMValue(89, autoSyncFrequency, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_activity_detect field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoActivityDetectValid() const + { + const Field* field = GetField(90); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns auto_activity_detect field + // Comment: Allows setting specific activities auto-activity detect enabled/disabled settings + /////////////////////////////////////////////////////////////////////// + FIT_AUTO_ACTIVITY_DETECT GetAutoActivityDetect(void) const + { + return GetFieldUINT32Value(90, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_activity_detect field + // Comment: Allows setting specific activities auto-activity detect enabled/disabled settings + /////////////////////////////////////////////////////////////////////// + void SetAutoActivityDetect(FIT_AUTO_ACTIVITY_DETECT autoActivityDetect) + { + SetFieldUINT32Value(90, autoActivityDetect, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of number_of_screens field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumberOfScreensValid() const + { + const Field* field = GetField(94); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number_of_screens field + // Comment: Number of screens configured to display + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumberOfScreens(void) const + { + return GetFieldUINT8Value(94, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set number_of_screens field + // Comment: Number of screens configured to display + /////////////////////////////////////////////////////////////////////// + void SetNumberOfScreens(FIT_UINT8 numberOfScreens) + { + SetFieldUINT8Value(94, numberOfScreens, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of smart_notification_display_orientation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSmartNotificationDisplayOrientationValid() const + { + const Field* field = GetField(95); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns smart_notification_display_orientation field + // Comment: Smart Notification display orientation + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_ORIENTATION GetSmartNotificationDisplayOrientation(void) const + { + return GetFieldENUMValue(95, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set smart_notification_display_orientation field + // Comment: Smart Notification display orientation + /////////////////////////////////////////////////////////////////////// + void SetSmartNotificationDisplayOrientation(FIT_DISPLAY_ORIENTATION smartNotificationDisplayOrientation) + { + SetFieldENUMValue(95, smartNotificationDisplayOrientation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of tap_interface field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTapInterfaceValid() const + { + const Field* field = GetField(134); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns tap_interface field + /////////////////////////////////////////////////////////////////////// + FIT_SWITCH GetTapInterface(void) const + { + return GetFieldENUMValue(134, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set tap_interface field + /////////////////////////////////////////////////////////////////////// + void SetTapInterface(FIT_SWITCH tapInterface) + { + SetFieldENUMValue(134, tapInterface, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of tap_sensitivity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTapSensitivityValid() const + { + const Field* field = GetField(174); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns tap_sensitivity field + // Comment: Used to hold the tap threshold setting + /////////////////////////////////////////////////////////////////////// + FIT_TAP_SENSITIVITY GetTapSensitivity(void) const + { + return GetFieldENUMValue(174, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set tap_sensitivity field + // Comment: Used to hold the tap threshold setting + /////////////////////////////////////////////////////////////////////// + void SetTapSensitivity(FIT_TAP_SENSITIVITY tapSensitivity) + { + SetFieldENUMValue(174, tapSensitivity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DEVICE_SETTINGS_MESG_HPP) diff --git a/fit_device_settings_mesg_listener.hpp b/fit_device_settings_mesg_listener.hpp new file mode 100644 index 0000000..a9c67cb --- /dev/null +++ b/fit_device_settings_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DEVICE_SETTINGS_MESG_LISTENER_HPP) +#define FIT_DEVICE_SETTINGS_MESG_LISTENER_HPP + +#include "fit_device_settings_mesg.hpp" + +namespace fit +{ + +class DeviceSettingsMesgListener +{ +public: + virtual ~DeviceSettingsMesgListener() {} + virtual void OnMesg(DeviceSettingsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DEVICE_SETTINGS_MESG_LISTENER_HPP) diff --git a/fit_dive_alarm_mesg.hpp b/fit_dive_alarm_mesg.hpp new file mode 100644 index 0000000..60e8e2c --- /dev/null +++ b/fit_dive_alarm_mesg.hpp @@ -0,0 +1,498 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_ALARM_MESG_HPP) +#define FIT_DIVE_ALARM_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DiveAlarmMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Depth = 0; + static const FIT_UINT8 Time = 1; + static const FIT_UINT8 Enabled = 2; + static const FIT_UINT8 AlarmType = 3; + static const FIT_UINT8 Sound = 4; + static const FIT_UINT8 DiveTypes = 5; + static const FIT_UINT8 Id = 6; + static const FIT_UINT8 PopupEnabled = 7; + static const FIT_UINT8 TriggerOnDescent = 8; + static const FIT_UINT8 TriggerOnAscent = 9; + static const FIT_UINT8 Repeating = 10; + static const FIT_UINT8 Speed = 11; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DiveAlarmMesg(void) : Mesg(Profile::MESG_DIVE_ALARM) + { + } + + DiveAlarmMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + // Comment: Index of the alarm + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + // Comment: Index of the alarm + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDepthValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns depth field + // Units: m + // Comment: Depth setting (m) for depth type alarms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDepth(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set depth field + // Units: m + // Comment: Depth setting (m) for depth type alarms + /////////////////////////////////////////////////////////////////////// + void SetDepth(FIT_FLOAT32 depth) + { + SetFieldFLOAT32Value(0, depth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time field + // Units: s + // Comment: Time setting (s) for time type alarms + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetTime(void) const + { + return GetFieldSINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time field + // Units: s + // Comment: Time setting (s) for time type alarms + /////////////////////////////////////////////////////////////////////// + void SetTime(FIT_SINT32 time) + { + SetFieldSINT32Value(1, time, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + // Comment: Enablement flag + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + // Comment: Enablement flag + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(2, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of alarm_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAlarmTypeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns alarm_type field + // Comment: Alarm type setting + /////////////////////////////////////////////////////////////////////// + FIT_DIVE_ALARM_TYPE GetAlarmType(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set alarm_type field + // Comment: Alarm type setting + /////////////////////////////////////////////////////////////////////// + void SetAlarmType(FIT_DIVE_ALARM_TYPE alarmType) + { + SetFieldENUMValue(3, alarmType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sound field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSoundValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sound field + // Comment: Tone and Vibe setting for the alarm + /////////////////////////////////////////////////////////////////////// + FIT_TONE GetSound(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sound field + // Comment: Tone and Vibe setting for the alarm + /////////////////////////////////////////////////////////////////////// + void SetSound(FIT_TONE sound) + { + SetFieldENUMValue(4, sound, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of dive_types + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumDiveTypes(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_types field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveTypesValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dive_types field + // Comment: Dive types the alarm will trigger on + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetDiveTypes(FIT_UINT8 index) const + { + return GetFieldENUMValue(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_types field + // Comment: Dive types the alarm will trigger on + /////////////////////////////////////////////////////////////////////// + void SetDiveTypes(FIT_UINT8 index, FIT_SUB_SPORT diveTypes) + { + SetFieldENUMValue(5, diveTypes, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIdValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns id field + // Comment: Alarm ID + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetId(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set id field + // Comment: Alarm ID + /////////////////////////////////////////////////////////////////////// + void SetId(FIT_UINT32 id) + { + SetFieldUINT32Value(6, id, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of popup_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPopupEnabledValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns popup_enabled field + // Comment: Show a visible pop-up for this alarm + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetPopupEnabled(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set popup_enabled field + // Comment: Show a visible pop-up for this alarm + /////////////////////////////////////////////////////////////////////// + void SetPopupEnabled(FIT_BOOL popupEnabled) + { + SetFieldENUMValue(7, popupEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of trigger_on_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTriggerOnDescentValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns trigger_on_descent field + // Comment: Trigger the alarm on descent + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetTriggerOnDescent(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set trigger_on_descent field + // Comment: Trigger the alarm on descent + /////////////////////////////////////////////////////////////////////// + void SetTriggerOnDescent(FIT_BOOL triggerOnDescent) + { + SetFieldENUMValue(8, triggerOnDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of trigger_on_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTriggerOnAscentValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns trigger_on_ascent field + // Comment: Trigger the alarm on ascent + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetTriggerOnAscent(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set trigger_on_ascent field + // Comment: Trigger the alarm on ascent + /////////////////////////////////////////////////////////////////////// + void SetTriggerOnAscent(FIT_BOOL triggerOnAscent) + { + SetFieldENUMValue(9, triggerOnAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeating field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatingValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repeating field + // Comment: Repeat alarm each time threshold is crossed? + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetRepeating(void) const + { + return GetFieldENUMValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeating field + // Comment: Repeat alarm each time threshold is crossed? + /////////////////////////////////////////////////////////////////////// + void SetRepeating(FIT_BOOL repeating) + { + SetFieldENUMValue(10, repeating, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed field + // Units: mps + // Comment: Ascent/descent rate (mps) setting for speed type alarms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeed(void) const + { + return GetFieldFLOAT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed field + // Units: mps + // Comment: Ascent/descent rate (mps) setting for speed type alarms + /////////////////////////////////////////////////////////////////////// + void SetSpeed(FIT_FLOAT32 speed) + { + SetFieldFLOAT32Value(11, speed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_ALARM_MESG_HPP) diff --git a/fit_dive_alarm_mesg_listener.hpp b/fit_dive_alarm_mesg_listener.hpp new file mode 100644 index 0000000..c30ad59 --- /dev/null +++ b/fit_dive_alarm_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_ALARM_MESG_LISTENER_HPP) +#define FIT_DIVE_ALARM_MESG_LISTENER_HPP + +#include "fit_dive_alarm_mesg.hpp" + +namespace fit +{ + +class DiveAlarmMesgListener +{ +public: + virtual ~DiveAlarmMesgListener() {} + virtual void OnMesg(DiveAlarmMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_ALARM_MESG_LISTENER_HPP) diff --git a/fit_dive_apnea_alarm_mesg.hpp b/fit_dive_apnea_alarm_mesg.hpp new file mode 100644 index 0000000..b87282c --- /dev/null +++ b/fit_dive_apnea_alarm_mesg.hpp @@ -0,0 +1,498 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_APNEA_ALARM_MESG_HPP) +#define FIT_DIVE_APNEA_ALARM_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DiveApneaAlarmMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Depth = 0; + static const FIT_UINT8 Time = 1; + static const FIT_UINT8 Enabled = 2; + static const FIT_UINT8 AlarmType = 3; + static const FIT_UINT8 Sound = 4; + static const FIT_UINT8 DiveTypes = 5; + static const FIT_UINT8 Id = 6; + static const FIT_UINT8 PopupEnabled = 7; + static const FIT_UINT8 TriggerOnDescent = 8; + static const FIT_UINT8 TriggerOnAscent = 9; + static const FIT_UINT8 Repeating = 10; + static const FIT_UINT8 Speed = 11; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DiveApneaAlarmMesg(void) : Mesg(Profile::MESG_DIVE_APNEA_ALARM) + { + } + + DiveApneaAlarmMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + // Comment: Index of the alarm + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + // Comment: Index of the alarm + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDepthValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns depth field + // Units: m + // Comment: Depth setting (m) for depth type alarms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDepth(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set depth field + // Units: m + // Comment: Depth setting (m) for depth type alarms + /////////////////////////////////////////////////////////////////////// + void SetDepth(FIT_FLOAT32 depth) + { + SetFieldFLOAT32Value(0, depth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time field + // Units: s + // Comment: Time setting (s) for time type alarms + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetTime(void) const + { + return GetFieldSINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time field + // Units: s + // Comment: Time setting (s) for time type alarms + /////////////////////////////////////////////////////////////////////// + void SetTime(FIT_SINT32 time) + { + SetFieldSINT32Value(1, time, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + // Comment: Enablement flag + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + // Comment: Enablement flag + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(2, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of alarm_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAlarmTypeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns alarm_type field + // Comment: Alarm type setting + /////////////////////////////////////////////////////////////////////// + FIT_DIVE_ALARM_TYPE GetAlarmType(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set alarm_type field + // Comment: Alarm type setting + /////////////////////////////////////////////////////////////////////// + void SetAlarmType(FIT_DIVE_ALARM_TYPE alarmType) + { + SetFieldENUMValue(3, alarmType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sound field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSoundValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sound field + // Comment: Tone and Vibe setting for the alarm. + /////////////////////////////////////////////////////////////////////// + FIT_TONE GetSound(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sound field + // Comment: Tone and Vibe setting for the alarm. + /////////////////////////////////////////////////////////////////////// + void SetSound(FIT_TONE sound) + { + SetFieldENUMValue(4, sound, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of dive_types + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumDiveTypes(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_types field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveTypesValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dive_types field + // Comment: Dive types the alarm will trigger on + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetDiveTypes(FIT_UINT8 index) const + { + return GetFieldENUMValue(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_types field + // Comment: Dive types the alarm will trigger on + /////////////////////////////////////////////////////////////////////// + void SetDiveTypes(FIT_UINT8 index, FIT_SUB_SPORT diveTypes) + { + SetFieldENUMValue(5, diveTypes, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIdValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns id field + // Comment: Alarm ID + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetId(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set id field + // Comment: Alarm ID + /////////////////////////////////////////////////////////////////////// + void SetId(FIT_UINT32 id) + { + SetFieldUINT32Value(6, id, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of popup_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPopupEnabledValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns popup_enabled field + // Comment: Show a visible pop-up for this alarm + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetPopupEnabled(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set popup_enabled field + // Comment: Show a visible pop-up for this alarm + /////////////////////////////////////////////////////////////////////// + void SetPopupEnabled(FIT_BOOL popupEnabled) + { + SetFieldENUMValue(7, popupEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of trigger_on_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTriggerOnDescentValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns trigger_on_descent field + // Comment: Trigger the alarm on descent + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetTriggerOnDescent(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set trigger_on_descent field + // Comment: Trigger the alarm on descent + /////////////////////////////////////////////////////////////////////// + void SetTriggerOnDescent(FIT_BOOL triggerOnDescent) + { + SetFieldENUMValue(8, triggerOnDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of trigger_on_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTriggerOnAscentValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns trigger_on_ascent field + // Comment: Trigger the alarm on ascent + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetTriggerOnAscent(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set trigger_on_ascent field + // Comment: Trigger the alarm on ascent + /////////////////////////////////////////////////////////////////////// + void SetTriggerOnAscent(FIT_BOOL triggerOnAscent) + { + SetFieldENUMValue(9, triggerOnAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeating field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatingValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repeating field + // Comment: Repeat alarm each time threshold is crossed? + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetRepeating(void) const + { + return GetFieldENUMValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeating field + // Comment: Repeat alarm each time threshold is crossed? + /////////////////////////////////////////////////////////////////////// + void SetRepeating(FIT_BOOL repeating) + { + SetFieldENUMValue(10, repeating, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed field + // Units: mps + // Comment: Ascent/descent rate (mps) setting for speed type alarms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeed(void) const + { + return GetFieldFLOAT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed field + // Units: mps + // Comment: Ascent/descent rate (mps) setting for speed type alarms + /////////////////////////////////////////////////////////////////////// + void SetSpeed(FIT_FLOAT32 speed) + { + SetFieldFLOAT32Value(11, speed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_APNEA_ALARM_MESG_HPP) diff --git a/fit_dive_apnea_alarm_mesg_listener.hpp b/fit_dive_apnea_alarm_mesg_listener.hpp new file mode 100644 index 0000000..e3a85cb --- /dev/null +++ b/fit_dive_apnea_alarm_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_APNEA_ALARM_MESG_LISTENER_HPP) +#define FIT_DIVE_APNEA_ALARM_MESG_LISTENER_HPP + +#include "fit_dive_apnea_alarm_mesg.hpp" + +namespace fit +{ + +class DiveApneaAlarmMesgListener +{ +public: + virtual ~DiveApneaAlarmMesgListener() {} + virtual void OnMesg(DiveApneaAlarmMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_APNEA_ALARM_MESG_LISTENER_HPP) diff --git a/fit_dive_gas_mesg.hpp b/fit_dive_gas_mesg.hpp new file mode 100644 index 0000000..d56806d --- /dev/null +++ b/fit_dive_gas_mesg.hpp @@ -0,0 +1,206 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_GAS_MESG_HPP) +#define FIT_DIVE_GAS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DiveGasMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 HeliumContent = 0; + static const FIT_UINT8 OxygenContent = 1; + static const FIT_UINT8 Status = 2; + static const FIT_UINT8 Mode = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DiveGasMesg(void) : Mesg(Profile::MESG_DIVE_GAS) + { + } + + DiveGasMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of helium_content field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeliumContentValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns helium_content field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHeliumContent(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set helium_content field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetHeliumContent(FIT_UINT8 heliumContent) + { + SetFieldUINT8Value(0, heliumContent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of oxygen_content field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOxygenContentValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns oxygen_content field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetOxygenContent(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set oxygen_content field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetOxygenContent(FIT_UINT8 oxygenContent) + { + SetFieldUINT8Value(1, oxygenContent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStatusValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns status field + /////////////////////////////////////////////////////////////////////// + FIT_DIVE_GAS_STATUS GetStatus(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set status field + /////////////////////////////////////////////////////////////////////// + void SetStatus(FIT_DIVE_GAS_STATUS status) + { + SetFieldENUMValue(2, status, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsModeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mode field + /////////////////////////////////////////////////////////////////////// + FIT_DIVE_GAS_MODE GetMode(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mode field + /////////////////////////////////////////////////////////////////////// + void SetMode(FIT_DIVE_GAS_MODE mode) + { + SetFieldENUMValue(3, mode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_GAS_MESG_HPP) diff --git a/fit_dive_gas_mesg_listener.hpp b/fit_dive_gas_mesg_listener.hpp new file mode 100644 index 0000000..d5cf262 --- /dev/null +++ b/fit_dive_gas_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_GAS_MESG_LISTENER_HPP) +#define FIT_DIVE_GAS_MESG_LISTENER_HPP + +#include "fit_dive_gas_mesg.hpp" + +namespace fit +{ + +class DiveGasMesgListener +{ +public: + virtual ~DiveGasMesgListener() {} + virtual void OnMesg(DiveGasMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_GAS_MESG_LISTENER_HPP) diff --git a/fit_dive_settings_mesg.hpp b/fit_dive_settings_mesg.hpp new file mode 100644 index 0000000..b097939 --- /dev/null +++ b/fit_dive_settings_mesg.hpp @@ -0,0 +1,1294 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_SETTINGS_MESG_HPP) +#define FIT_DIVE_SETTINGS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DiveSettingsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Name = 0; + static const FIT_UINT8 Model = 1; + static const FIT_UINT8 GfLow = 2; + static const FIT_UINT8 GfHigh = 3; + static const FIT_UINT8 WaterType = 4; + static const FIT_UINT8 WaterDensity = 5; + static const FIT_UINT8 Po2Warn = 6; + static const FIT_UINT8 Po2Critical = 7; + static const FIT_UINT8 Po2Deco = 8; + static const FIT_UINT8 SafetyStopEnabled = 9; + static const FIT_UINT8 BottomDepth = 10; + static const FIT_UINT8 BottomTime = 11; + static const FIT_UINT8 ApneaCountdownEnabled = 12; + static const FIT_UINT8 ApneaCountdownTime = 13; + static const FIT_UINT8 BacklightMode = 14; + static const FIT_UINT8 BacklightBrightness = 15; + static const FIT_UINT8 BacklightTimeout = 16; + static const FIT_UINT8 RepeatDiveInterval = 17; + static const FIT_UINT8 SafetyStopTime = 18; + static const FIT_UINT8 HeartRateSourceType = 19; + static const FIT_UINT8 HeartRateSource = 20; + static const FIT_UINT8 TravelGas = 21; + static const FIT_UINT8 CcrLowSetpointSwitchMode = 22; + static const FIT_UINT8 CcrLowSetpoint = 23; + static const FIT_UINT8 CcrLowSetpointDepth = 24; + static const FIT_UINT8 CcrHighSetpointSwitchMode = 25; + static const FIT_UINT8 CcrHighSetpoint = 26; + static const FIT_UINT8 CcrHighSetpointDepth = 27; + static const FIT_UINT8 GasConsumptionDisplay = 29; + static const FIT_UINT8 UpKeyEnabled = 30; + static const FIT_UINT8 DiveSounds = 35; + static const FIT_UINT8 LastStopMultiple = 36; + static const FIT_UINT8 NoFlyTimeMode = 37; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DiveSettingsMesg(void) : Mesg(Profile::MESG_DIVE_SETTINGS) + { + } + + DiveSettingsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(0, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of model field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsModelValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns model field + /////////////////////////////////////////////////////////////////////// + FIT_TISSUE_MODEL_TYPE GetModel(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set model field + /////////////////////////////////////////////////////////////////////// + void SetModel(FIT_TISSUE_MODEL_TYPE model) + { + SetFieldENUMValue(1, model, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gf_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGfLowValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gf_low field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGfLow(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gf_low field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetGfLow(FIT_UINT8 gfLow) + { + SetFieldUINT8Value(2, gfLow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gf_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGfHighValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gf_high field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGfHigh(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gf_high field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetGfHigh(FIT_UINT8 gfHigh) + { + SetFieldUINT8Value(3, gfHigh, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of water_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWaterTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns water_type field + /////////////////////////////////////////////////////////////////////// + FIT_WATER_TYPE GetWaterType(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set water_type field + /////////////////////////////////////////////////////////////////////// + void SetWaterType(FIT_WATER_TYPE waterType) + { + SetFieldENUMValue(4, waterType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of water_density field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWaterDensityValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns water_density field + // Units: kg/m^3 + // Comment: Fresh water is usually 1000; salt water is usually 1025 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetWaterDensity(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set water_density field + // Units: kg/m^3 + // Comment: Fresh water is usually 1000; salt water is usually 1025 + /////////////////////////////////////////////////////////////////////// + void SetWaterDensity(FIT_FLOAT32 waterDensity) + { + SetFieldFLOAT32Value(5, waterDensity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of po2_warn field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPo2WarnValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns po2_warn field + // Units: percent + // Comment: Typically 1.40 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPo2Warn(void) const + { + return GetFieldFLOAT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set po2_warn field + // Units: percent + // Comment: Typically 1.40 + /////////////////////////////////////////////////////////////////////// + void SetPo2Warn(FIT_FLOAT32 po2Warn) + { + SetFieldFLOAT32Value(6, po2Warn, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of po2_critical field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPo2CriticalValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns po2_critical field + // Units: percent + // Comment: Typically 1.60 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPo2Critical(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set po2_critical field + // Units: percent + // Comment: Typically 1.60 + /////////////////////////////////////////////////////////////////////// + void SetPo2Critical(FIT_FLOAT32 po2Critical) + { + SetFieldFLOAT32Value(7, po2Critical, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of po2_deco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPo2DecoValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns po2_deco field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPo2Deco(void) const + { + return GetFieldFLOAT32Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set po2_deco field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetPo2Deco(FIT_FLOAT32 po2Deco) + { + SetFieldFLOAT32Value(8, po2Deco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of safety_stop_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSafetyStopEnabledValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns safety_stop_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetSafetyStopEnabled(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set safety_stop_enabled field + /////////////////////////////////////////////////////////////////////// + void SetSafetyStopEnabled(FIT_BOOL safetyStopEnabled) + { + SetFieldENUMValue(9, safetyStopEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bottom_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBottomDepthValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bottom_depth field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBottomDepth(void) const + { + return GetFieldFLOAT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bottom_depth field + /////////////////////////////////////////////////////////////////////// + void SetBottomDepth(FIT_FLOAT32 bottomDepth) + { + SetFieldFLOAT32Value(10, bottomDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bottom_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBottomTimeValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bottom_time field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetBottomTime(void) const + { + return GetFieldUINT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bottom_time field + /////////////////////////////////////////////////////////////////////// + void SetBottomTime(FIT_UINT32 bottomTime) + { + SetFieldUINT32Value(11, bottomTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of apnea_countdown_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsApneaCountdownEnabledValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns apnea_countdown_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetApneaCountdownEnabled(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set apnea_countdown_enabled field + /////////////////////////////////////////////////////////////////////// + void SetApneaCountdownEnabled(FIT_BOOL apneaCountdownEnabled) + { + SetFieldENUMValue(12, apneaCountdownEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of apnea_countdown_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsApneaCountdownTimeValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns apnea_countdown_time field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetApneaCountdownTime(void) const + { + return GetFieldUINT32Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set apnea_countdown_time field + /////////////////////////////////////////////////////////////////////// + void SetApneaCountdownTime(FIT_UINT32 apneaCountdownTime) + { + SetFieldUINT32Value(13, apneaCountdownTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of backlight_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBacklightModeValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns backlight_mode field + /////////////////////////////////////////////////////////////////////// + FIT_DIVE_BACKLIGHT_MODE GetBacklightMode(void) const + { + return GetFieldENUMValue(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set backlight_mode field + /////////////////////////////////////////////////////////////////////// + void SetBacklightMode(FIT_DIVE_BACKLIGHT_MODE backlightMode) + { + SetFieldENUMValue(14, backlightMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of backlight_brightness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBacklightBrightnessValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns backlight_brightness field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetBacklightBrightness(void) const + { + return GetFieldUINT8Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set backlight_brightness field + /////////////////////////////////////////////////////////////////////// + void SetBacklightBrightness(FIT_UINT8 backlightBrightness) + { + SetFieldUINT8Value(15, backlightBrightness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of backlight_timeout field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBacklightTimeoutValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns backlight_timeout field + /////////////////////////////////////////////////////////////////////// + FIT_BACKLIGHT_TIMEOUT GetBacklightTimeout(void) const + { + return GetFieldUINT8Value(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set backlight_timeout field + /////////////////////////////////////////////////////////////////////// + void SetBacklightTimeout(FIT_BACKLIGHT_TIMEOUT backlightTimeout) + { + SetFieldUINT8Value(16, backlightTimeout, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_dive_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatDiveIntervalValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_dive_interval field + // Units: s + // Comment: Time between surfacing and ending the activity + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRepeatDiveInterval(void) const + { + return GetFieldUINT16Value(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_dive_interval field + // Units: s + // Comment: Time between surfacing and ending the activity + /////////////////////////////////////////////////////////////////////// + void SetRepeatDiveInterval(FIT_UINT16 repeatDiveInterval) + { + SetFieldUINT16Value(17, repeatDiveInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of safety_stop_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSafetyStopTimeValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns safety_stop_time field + // Units: s + // Comment: Time at safety stop (if enabled) + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSafetyStopTime(void) const + { + return GetFieldUINT16Value(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set safety_stop_time field + // Units: s + // Comment: Time at safety stop (if enabled) + /////////////////////////////////////////////////////////////////////// + void SetSafetyStopTime(FIT_UINT16 safetyStopTime) + { + SetFieldUINT16Value(18, safetyStopTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate_source_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateSourceTypeValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate_source_type field + /////////////////////////////////////////////////////////////////////// + FIT_SOURCE_TYPE GetHeartRateSourceType(void) const + { + return GetFieldENUMValue(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate_source_type field + /////////////////////////////////////////////////////////////////////// + void SetHeartRateSourceType(FIT_SOURCE_TYPE heartRateSourceType) + { + SetFieldENUMValue(19, heartRateSourceType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate_source field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateSourceValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate_source field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHeartRateSource(void) const + { + return GetFieldUINT8Value(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate_source field + /////////////////////////////////////////////////////////////////////// + void SetHeartRateSource(FIT_UINT8 heartRateSource) + { + SetFieldUINT8Value(20, heartRateSource, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate_antplus_device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateAntplusDeviceTypeValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_ANTPLUS_DEVICE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_ANTPLUS_DEVICE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate_antplus_device_type field + /////////////////////////////////////////////////////////////////////// + FIT_ANTPLUS_DEVICE_TYPE GetHeartRateAntplusDeviceType(void) const + { + return GetFieldUINT8Value(20, 0, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_ANTPLUS_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate_antplus_device_type field + /////////////////////////////////////////////////////////////////////// + void SetHeartRateAntplusDeviceType(FIT_ANTPLUS_DEVICE_TYPE heartRateAntplusDeviceType) + { + SetFieldUINT8Value(20, heartRateAntplusDeviceType, 0, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_ANTPLUS_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate_local_device_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateLocalDeviceTypeValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_LOCAL_DEVICE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_LOCAL_DEVICE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate_local_device_type field + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DEVICE_TYPE GetHeartRateLocalDeviceType(void) const + { + return GetFieldUINT8Value(20, 0, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_LOCAL_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate_local_device_type field + /////////////////////////////////////////////////////////////////////// + void SetHeartRateLocalDeviceType(FIT_LOCAL_DEVICE_TYPE heartRateLocalDeviceType) + { + SetFieldUINT8Value(20, heartRateLocalDeviceType, 0, (FIT_UINT16) Profile::DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_LOCAL_DEVICE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of travel_gas field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTravelGasValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns travel_gas field + // Comment: Index of travel dive_gas message + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetTravelGas(void) const + { + return GetFieldUINT16Value(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set travel_gas field + // Comment: Index of travel dive_gas message + /////////////////////////////////////////////////////////////////////// + void SetTravelGas(FIT_MESSAGE_INDEX travelGas) + { + SetFieldUINT16Value(21, travelGas, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ccr_low_setpoint_switch_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCcrLowSetpointSwitchModeValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ccr_low_setpoint_switch_mode field + // Comment: If low PO2 should be switched to automatically + /////////////////////////////////////////////////////////////////////// + FIT_CCR_SETPOINT_SWITCH_MODE GetCcrLowSetpointSwitchMode(void) const + { + return GetFieldENUMValue(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ccr_low_setpoint_switch_mode field + // Comment: If low PO2 should be switched to automatically + /////////////////////////////////////////////////////////////////////// + void SetCcrLowSetpointSwitchMode(FIT_CCR_SETPOINT_SWITCH_MODE ccrLowSetpointSwitchMode) + { + SetFieldENUMValue(22, ccrLowSetpointSwitchMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ccr_low_setpoint field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCcrLowSetpointValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ccr_low_setpoint field + // Units: percent + // Comment: Target PO2 when using low setpoint + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCcrLowSetpoint(void) const + { + return GetFieldFLOAT32Value(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ccr_low_setpoint field + // Units: percent + // Comment: Target PO2 when using low setpoint + /////////////////////////////////////////////////////////////////////// + void SetCcrLowSetpoint(FIT_FLOAT32 ccrLowSetpoint) + { + SetFieldFLOAT32Value(23, ccrLowSetpoint, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ccr_low_setpoint_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCcrLowSetpointDepthValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ccr_low_setpoint_depth field + // Units: m + // Comment: Depth to switch to low setpoint in automatic mode + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCcrLowSetpointDepth(void) const + { + return GetFieldFLOAT32Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ccr_low_setpoint_depth field + // Units: m + // Comment: Depth to switch to low setpoint in automatic mode + /////////////////////////////////////////////////////////////////////// + void SetCcrLowSetpointDepth(FIT_FLOAT32 ccrLowSetpointDepth) + { + SetFieldFLOAT32Value(24, ccrLowSetpointDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ccr_high_setpoint_switch_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCcrHighSetpointSwitchModeValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ccr_high_setpoint_switch_mode field + // Comment: If high PO2 should be switched to automatically + /////////////////////////////////////////////////////////////////////// + FIT_CCR_SETPOINT_SWITCH_MODE GetCcrHighSetpointSwitchMode(void) const + { + return GetFieldENUMValue(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ccr_high_setpoint_switch_mode field + // Comment: If high PO2 should be switched to automatically + /////////////////////////////////////////////////////////////////////// + void SetCcrHighSetpointSwitchMode(FIT_CCR_SETPOINT_SWITCH_MODE ccrHighSetpointSwitchMode) + { + SetFieldENUMValue(25, ccrHighSetpointSwitchMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ccr_high_setpoint field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCcrHighSetpointValid() const + { + const Field* field = GetField(26); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ccr_high_setpoint field + // Units: percent + // Comment: Target PO2 when using high setpoint + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCcrHighSetpoint(void) const + { + return GetFieldFLOAT32Value(26, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ccr_high_setpoint field + // Units: percent + // Comment: Target PO2 when using high setpoint + /////////////////////////////////////////////////////////////////////// + void SetCcrHighSetpoint(FIT_FLOAT32 ccrHighSetpoint) + { + SetFieldFLOAT32Value(26, ccrHighSetpoint, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ccr_high_setpoint_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCcrHighSetpointDepthValid() const + { + const Field* field = GetField(27); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ccr_high_setpoint_depth field + // Units: m + // Comment: Depth to switch to high setpoint in automatic mode + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCcrHighSetpointDepth(void) const + { + return GetFieldFLOAT32Value(27, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ccr_high_setpoint_depth field + // Units: m + // Comment: Depth to switch to high setpoint in automatic mode + /////////////////////////////////////////////////////////////////////// + void SetCcrHighSetpointDepth(FIT_FLOAT32 ccrHighSetpointDepth) + { + SetFieldFLOAT32Value(27, ccrHighSetpointDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gas_consumption_display field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGasConsumptionDisplayValid() const + { + const Field* field = GetField(29); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gas_consumption_display field + // Comment: Type of gas consumption rate to display. Some values are only valid if tank volume is known. + /////////////////////////////////////////////////////////////////////// + FIT_GAS_CONSUMPTION_RATE_TYPE GetGasConsumptionDisplay(void) const + { + return GetFieldENUMValue(29, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gas_consumption_display field + // Comment: Type of gas consumption rate to display. Some values are only valid if tank volume is known. + /////////////////////////////////////////////////////////////////////// + void SetGasConsumptionDisplay(FIT_GAS_CONSUMPTION_RATE_TYPE gasConsumptionDisplay) + { + SetFieldENUMValue(29, gasConsumptionDisplay, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of up_key_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUpKeyEnabledValid() const + { + const Field* field = GetField(30); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns up_key_enabled field + // Comment: Indicates whether the up key is enabled during dives + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetUpKeyEnabled(void) const + { + return GetFieldENUMValue(30, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set up_key_enabled field + // Comment: Indicates whether the up key is enabled during dives + /////////////////////////////////////////////////////////////////////// + void SetUpKeyEnabled(FIT_BOOL upKeyEnabled) + { + SetFieldENUMValue(30, upKeyEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_sounds field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveSoundsValid() const + { + const Field* field = GetField(35); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dive_sounds field + // Comment: Sounds and vibration enabled or disabled in-dive + /////////////////////////////////////////////////////////////////////// + FIT_TONE GetDiveSounds(void) const + { + return GetFieldENUMValue(35, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_sounds field + // Comment: Sounds and vibration enabled or disabled in-dive + /////////////////////////////////////////////////////////////////////// + void SetDiveSounds(FIT_TONE diveSounds) + { + SetFieldENUMValue(35, diveSounds, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of last_stop_multiple field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLastStopMultipleValid() const + { + const Field* field = GetField(36); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns last_stop_multiple field + // Comment: Usually 1.0/1.5/2.0 representing 3/4.5/6m or 10/15/20ft + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLastStopMultiple(void) const + { + return GetFieldFLOAT32Value(36, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set last_stop_multiple field + // Comment: Usually 1.0/1.5/2.0 representing 3/4.5/6m or 10/15/20ft + /////////////////////////////////////////////////////////////////////// + void SetLastStopMultiple(FIT_FLOAT32 lastStopMultiple) + { + SetFieldFLOAT32Value(36, lastStopMultiple, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of no_fly_time_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNoFlyTimeModeValid() const + { + const Field* field = GetField(37); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns no_fly_time_mode field + // Comment: Indicates which guidelines to use for no-fly surface interval. + /////////////////////////////////////////////////////////////////////// + FIT_NO_FLY_TIME_MODE GetNoFlyTimeMode(void) const + { + return GetFieldENUMValue(37, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set no_fly_time_mode field + // Comment: Indicates which guidelines to use for no-fly surface interval. + /////////////////////////////////////////////////////////////////////// + void SetNoFlyTimeMode(FIT_NO_FLY_TIME_MODE noFlyTimeMode) + { + SetFieldENUMValue(37, noFlyTimeMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_SETTINGS_MESG_HPP) diff --git a/fit_dive_settings_mesg_listener.hpp b/fit_dive_settings_mesg_listener.hpp new file mode 100644 index 0000000..e0d00c0 --- /dev/null +++ b/fit_dive_settings_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_SETTINGS_MESG_LISTENER_HPP) +#define FIT_DIVE_SETTINGS_MESG_LISTENER_HPP + +#include "fit_dive_settings_mesg.hpp" + +namespace fit +{ + +class DiveSettingsMesgListener +{ +public: + virtual ~DiveSettingsMesgListener() {} + virtual void OnMesg(DiveSettingsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_SETTINGS_MESG_LISTENER_HPP) diff --git a/fit_dive_summary_mesg.hpp b/fit_dive_summary_mesg.hpp new file mode 100644 index 0000000..c48152c --- /dev/null +++ b/fit_dive_summary_mesg.hpp @@ -0,0 +1,844 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_SUMMARY_MESG_HPP) +#define FIT_DIVE_SUMMARY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class DiveSummaryMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ReferenceMesg = 0; + static const FIT_UINT8 ReferenceIndex = 1; + static const FIT_UINT8 AvgDepth = 2; + static const FIT_UINT8 MaxDepth = 3; + static const FIT_UINT8 SurfaceInterval = 4; + static const FIT_UINT8 StartCns = 5; + static const FIT_UINT8 EndCns = 6; + static const FIT_UINT8 StartN2 = 7; + static const FIT_UINT8 EndN2 = 8; + static const FIT_UINT8 O2Toxicity = 9; + static const FIT_UINT8 DiveNumber = 10; + static const FIT_UINT8 BottomTime = 11; + static const FIT_UINT8 AvgPressureSac = 12; + static const FIT_UINT8 AvgVolumeSac = 13; + static const FIT_UINT8 AvgRmv = 14; + static const FIT_UINT8 DescentTime = 15; + static const FIT_UINT8 AscentTime = 16; + static const FIT_UINT8 AvgAscentRate = 17; + static const FIT_UINT8 AvgDescentRate = 22; + static const FIT_UINT8 MaxAscentRate = 23; + static const FIT_UINT8 MaxDescentRate = 24; + static const FIT_UINT8 HangTime = 25; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + DiveSummaryMesg(void) : Mesg(Profile::MESG_DIVE_SUMMARY) + { + } + + DiveSummaryMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reference_mesg field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReferenceMesgValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reference_mesg field + /////////////////////////////////////////////////////////////////////// + FIT_MESG_NUM GetReferenceMesg(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reference_mesg field + /////////////////////////////////////////////////////////////////////// + void SetReferenceMesg(FIT_MESG_NUM referenceMesg) + { + SetFieldUINT16Value(0, referenceMesg, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reference_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReferenceIndexValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reference_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetReferenceIndex(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reference_index field + /////////////////////////////////////////////////////////////////////// + void SetReferenceIndex(FIT_MESSAGE_INDEX referenceIndex) + { + SetFieldUINT16Value(1, referenceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgDepthValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgDepth(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetAvgDepth(FIT_FLOAT32 avgDepth) + { + SetFieldFLOAT32Value(2, avgDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxDepthValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxDepth(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetMaxDepth(FIT_FLOAT32 maxDepth) + { + SetFieldFLOAT32Value(3, maxDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of surface_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSurfaceIntervalValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns surface_interval field + // Units: s + // Comment: Time since end of last dive + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSurfaceInterval(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set surface_interval field + // Units: s + // Comment: Time since end of last dive + /////////////////////////////////////////////////////////////////////// + void SetSurfaceInterval(FIT_UINT32 surfaceInterval) + { + SetFieldUINT32Value(4, surfaceInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_cns field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartCnsValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetStartCns(void) const + { + return GetFieldUINT8Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetStartCns(FIT_UINT8 startCns) + { + SetFieldUINT8Value(5, startCns, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_cns field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndCnsValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEndCns(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetEndCns(FIT_UINT8 endCns) + { + SetFieldUINT8Value(6, endCns, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_n2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartN2Valid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStartN2(void) const + { + return GetFieldUINT16Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetStartN2(FIT_UINT16 startN2) + { + SetFieldUINT16Value(7, startN2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_n2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndN2Valid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetEndN2(void) const + { + return GetFieldUINT16Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetEndN2(FIT_UINT16 endN2) + { + SetFieldUINT16Value(8, endN2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of o2_toxicity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsO2ToxicityValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns o2_toxicity field + // Units: OTUs + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetO2Toxicity(void) const + { + return GetFieldUINT16Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set o2_toxicity field + // Units: OTUs + /////////////////////////////////////////////////////////////////////// + void SetO2Toxicity(FIT_UINT16 o2Toxicity) + { + SetFieldUINT16Value(9, o2Toxicity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveNumberValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dive_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDiveNumber(void) const + { + return GetFieldUINT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_number field + /////////////////////////////////////////////////////////////////////// + void SetDiveNumber(FIT_UINT32 diveNumber) + { + SetFieldUINT32Value(10, diveNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bottom_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBottomTimeValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bottom_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBottomTime(void) const + { + return GetFieldFLOAT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bottom_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetBottomTime(FIT_FLOAT32 bottomTime) + { + SetFieldFLOAT32Value(11, bottomTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pressure_sac field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPressureSacValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pressure_sac field + // Units: bar/min + // Comment: Average pressure-based surface air consumption + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPressureSac(void) const + { + return GetFieldFLOAT32Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pressure_sac field + // Units: bar/min + // Comment: Average pressure-based surface air consumption + /////////////////////////////////////////////////////////////////////// + void SetAvgPressureSac(FIT_FLOAT32 avgPressureSac) + { + SetFieldFLOAT32Value(12, avgPressureSac, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_volume_sac field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVolumeSacValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_volume_sac field + // Units: L/min + // Comment: Average volumetric surface air consumption + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVolumeSac(void) const + { + return GetFieldFLOAT32Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_volume_sac field + // Units: L/min + // Comment: Average volumetric surface air consumption + /////////////////////////////////////////////////////////////////////// + void SetAvgVolumeSac(FIT_FLOAT32 avgVolumeSac) + { + SetFieldFLOAT32Value(13, avgVolumeSac, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_rmv field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRmvValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_rmv field + // Units: L/min + // Comment: Average respiratory minute volume + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRmv(void) const + { + return GetFieldFLOAT32Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_rmv field + // Units: L/min + // Comment: Average respiratory minute volume + /////////////////////////////////////////////////////////////////////// + void SetAvgRmv(FIT_FLOAT32 avgRmv) + { + SetFieldFLOAT32Value(14, avgRmv, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of descent_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDescentTimeValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns descent_time field + // Units: s + // Comment: Time to reach deepest level stop + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDescentTime(void) const + { + return GetFieldFLOAT32Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set descent_time field + // Units: s + // Comment: Time to reach deepest level stop + /////////////////////////////////////////////////////////////////////// + void SetDescentTime(FIT_FLOAT32 descentTime) + { + SetFieldFLOAT32Value(15, descentTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ascent_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAscentTimeValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ascent_time field + // Units: s + // Comment: Time after leaving bottom until reaching surface + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAscentTime(void) const + { + return GetFieldFLOAT32Value(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ascent_time field + // Units: s + // Comment: Time after leaving bottom until reaching surface + /////////////////////////////////////////////////////////////////////// + void SetAscentTime(FIT_FLOAT32 ascentTime) + { + SetFieldFLOAT32Value(16, ascentTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_ascent_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgAscentRateValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_ascent_rate field + // Units: m/s + // Comment: Average ascent rate, not including descents or stops + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgAscentRate(void) const + { + return GetFieldFLOAT32Value(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_ascent_rate field + // Units: m/s + // Comment: Average ascent rate, not including descents or stops + /////////////////////////////////////////////////////////////////////// + void SetAvgAscentRate(FIT_FLOAT32 avgAscentRate) + { + SetFieldFLOAT32Value(17, avgAscentRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_descent_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgDescentRateValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_descent_rate field + // Units: m/s + // Comment: Average descent rate, not including ascents or stops + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgDescentRate(void) const + { + return GetFieldFLOAT32Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_descent_rate field + // Units: m/s + // Comment: Average descent rate, not including ascents or stops + /////////////////////////////////////////////////////////////////////// + void SetAvgDescentRate(FIT_FLOAT32 avgDescentRate) + { + SetFieldFLOAT32Value(22, avgDescentRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_ascent_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxAscentRateValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_ascent_rate field + // Units: m/s + // Comment: Maximum ascent rate + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxAscentRate(void) const + { + return GetFieldFLOAT32Value(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_ascent_rate field + // Units: m/s + // Comment: Maximum ascent rate + /////////////////////////////////////////////////////////////////////// + void SetMaxAscentRate(FIT_FLOAT32 maxAscentRate) + { + SetFieldFLOAT32Value(23, maxAscentRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_descent_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxDescentRateValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_descent_rate field + // Units: m/s + // Comment: Maximum descent rate + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxDescentRate(void) const + { + return GetFieldFLOAT32Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_descent_rate field + // Units: m/s + // Comment: Maximum descent rate + /////////////////////////////////////////////////////////////////////// + void SetMaxDescentRate(FIT_FLOAT32 maxDescentRate) + { + SetFieldFLOAT32Value(24, maxDescentRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hang_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHangTimeValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hang_time field + // Units: s + // Comment: Time spent neither ascending nor descending + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetHangTime(void) const + { + return GetFieldFLOAT32Value(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hang_time field + // Units: s + // Comment: Time spent neither ascending nor descending + /////////////////////////////////////////////////////////////////////// + void SetHangTime(FIT_FLOAT32 hangTime) + { + SetFieldFLOAT32Value(25, hangTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_SUMMARY_MESG_HPP) diff --git a/fit_dive_summary_mesg_listener.hpp b/fit_dive_summary_mesg_listener.hpp new file mode 100644 index 0000000..01f5aae --- /dev/null +++ b/fit_dive_summary_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_DIVE_SUMMARY_MESG_LISTENER_HPP) +#define FIT_DIVE_SUMMARY_MESG_LISTENER_HPP + +#include "fit_dive_summary_mesg.hpp" + +namespace fit +{ + +class DiveSummaryMesgListener +{ +public: + virtual ~DiveSummaryMesgListener() {} + virtual void OnMesg(DiveSummaryMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_DIVE_SUMMARY_MESG_LISTENER_HPP) diff --git a/fit_encode.cpp b/fit_encode.cpp new file mode 100644 index 0000000..3366988 --- /dev/null +++ b/fit_encode.cpp @@ -0,0 +1,126 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include "fit_encode.hpp" +#include "fit_crc.hpp" + +namespace fit +{ +Encode::Encode() + : Encode( ProtocolVersion::V10 ) {} + +Encode::Encode( ProtocolVersion version ) + : dataSize( 0 ) + , file( nullptr ) + , version( version ) + , validator( version ) {} + +void Encode::Open(std::iostream &file) +{ + this->file = &file; + WriteFileHeader(); +} + +void Encode::Write( const MesgDefinition& mesgDef ) +{ + if ( !file ) + return; + + if ( !validator.ValidateMesgDefn( mesgDef ) ) + return; + + dataSize += mesgDef.Write( *file ); + lastMesgDefinition[mesgDef.GetLocalNum()] = mesgDef; +} + +void Encode::Write( const Mesg& mesg ) +{ + MesgDefinition mesgDefinition( mesg ); + + if ( !file ) + return; + + if ( !validator.ValidateMesg( mesg ) ) + return; + + if ( !lastMesgDefinition[mesg.GetLocalNum()].Supports( mesgDefinition ) ) + Write( mesgDefinition ); + + dataSize += mesg.Write( *file, &( lastMesgDefinition[mesg.GetLocalNum()] ) ); +} + +void Encode::Write( const std::vector& mesgs ) +{ + for ( std::vector::size_type i = 0; i < mesgs.size(); i++ ) + Write( mesgs[i] ); +} + +FIT_BOOL Encode::Close( void ) +{ + FIT_UINT32 fileBytesLeft = FIT_FILE_HDR_SIZE + dataSize; + FIT_UINT16 crc = 0; + + if ( !file ) + return FIT_FALSE; + + WriteFileHeader(); + + file->seekg( 0, std::ios::beg ); + + while ( fileBytesLeft > 0 ) + { + FIT_UINT8 byte = ( FIT_UINT8 )file->get(); + + if ( file->eof() ) + return FIT_FALSE; // File smaller than expected. + + crc = CRC::Get16( crc, byte ); + fileBytesLeft--; + } + + file->seekp( 0, std::ios::end ); + file->put( crc & 0xFF ); + file->put( ( char )( crc >> 8 ) ); + + return FIT_TRUE; +} + +void Encode::OnMesg( Mesg& mesg ) +{ + Write( mesg ); +} + +void Encode::OnMesgDefinition( MesgDefinition& mesgDef ) +{ + Write( mesgDef ); +} + +void Encode::WriteFileHeader() +{ + FIT_FILE_HDR file_header; + + if ( !file ) + return; + + file_header.header_size = FIT_FILE_HDR_SIZE; + file_header.profile_version = FIT_PROFILE_VERSION; + file_header.protocol_version = fit::versionMap.at( version ).GetVersionByte(); + memcpy( ( FIT_UINT8 * )&file_header.data_type, ".FIT", 4 ); + file_header.data_size = dataSize; + file_header.crc = CRC::Calc16( &file_header, FIT_STRUCT_OFFSET(crc, FIT_FILE_HDR) ); + + file->seekp( 0, std::ios::beg ); + file->write( ( const char * )&file_header, FIT_FILE_HDR_SIZE ); +} +} // namespace fit + diff --git a/fit_encode.hpp b/fit_encode.hpp new file mode 100644 index 0000000..c49e8a0 --- /dev/null +++ b/fit_encode.hpp @@ -0,0 +1,63 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ENCODE_HPP) +#define FIT_ENCODE_HPP + +#include +#include +#include "fit.hpp" +#include "fit_mesg.hpp" +#include "fit_mesg_definition.hpp" +#include "fit_mesg_definition_listener.hpp" +#include "fit_mesg_listener.hpp" +#include "fit_protocol_validator.hpp" + +namespace fit +{ + +class Encode + : public MesgListener + , public MesgDefinitionListener +{ +public: + DEPRECATED + ( + "Encode now supports multiple protocol version encoding use: " + "Encode::Encode(fit::ProtocolVersion) to ensure features " + "are correctly validated" + ) + Encode(void); + Encode( ProtocolVersion version ); + + void Open(std::iostream& file); + void Write(const MesgDefinition& mesgDef); + void Write(const Mesg& mesg); + void Write(const std::vector& mesgs); + FIT_BOOL Close(void); + void OnMesg(Mesg& mesg); + void OnMesgDefinition(MesgDefinition& mesgDef); + +private: + void WriteFileHeader(); + + MesgDefinition lastMesgDefinition[FIT_MAX_LOCAL_MESGS]; + FIT_UINT32 dataSize; + std::iostream *file; + + ProtocolVersion version; + ProtocolValidator validator; +}; + +} // namespace fit + +#endif // defined(FIT_ENCODE_HPP) diff --git a/fit_event_mesg.hpp b/fit_event_mesg.hpp new file mode 100644 index 0000000..f1147cc --- /dev/null +++ b/fit_event_mesg.hpp @@ -0,0 +1,1607 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EVENT_MESG_HPP) +#define FIT_EVENT_MESG_HPP + +#include "fit_mesg.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class EventMesg : public Mesg, public MesgWithEvent +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Event = 0; + static const FIT_UINT8 EventType = 1; + static const FIT_UINT8 Data16 = 2; + static const FIT_UINT8 Data = 3; + static const FIT_UINT8 EventGroup = 4; + static const FIT_UINT8 Score = 7; + static const FIT_UINT8 OpponentScore = 8; + static const FIT_UINT8 FrontGearNum = 9; + static const FIT_UINT8 FrontGear = 10; + static const FIT_UINT8 RearGearNum = 11; + static const FIT_UINT8 RearGear = 12; + static const FIT_UINT8 DeviceIndex = 13; + static const FIT_UINT8 ActivityType = 14; + static const FIT_UINT8 StartTimestamp = 15; + static const FIT_UINT8 RadarThreatLevelMax = 21; + static const FIT_UINT8 RadarThreatCount = 22; + static const FIT_UINT8 RadarThreatAvgApproachSpeed = 23; + static const FIT_UINT8 RadarThreatMaxApproachSpeed = 24; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + EventMesg(void) : Mesg(Profile::MESG_EVENT) + { + } + + EventMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT GetEvent(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event field + /////////////////////////////////////////////////////////////////////// + void SetEvent(FIT_EVENT event) + { + SetFieldENUMValue(0, event, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_type field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT_TYPE GetEventType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_type field + /////////////////////////////////////////////////////////////////////// + void SetEventType(FIT_EVENT_TYPE eventType) + { + SetFieldENUMValue(1, eventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data16 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsData16Valid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data16 field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetData16(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data16 field + /////////////////////////////////////////////////////////////////////// + void SetData16(FIT_UINT16 data16) + { + SetFieldUINT16Value(2, data16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetData(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data field + /////////////////////////////////////////////////////////////////////// + void SetData(FIT_UINT32 data) + { + SetFieldUINT32Value(3, data, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timer_trigger field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimerTriggerValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIMER_TRIGGER ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIMER_TRIGGER); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns timer_trigger field + /////////////////////////////////////////////////////////////////////// + FIT_TIMER_TRIGGER GetTimerTrigger(void) const + { + return GetFieldENUMValue(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIMER_TRIGGER); + } + + /////////////////////////////////////////////////////////////////////// + // Set timer_trigger field + /////////////////////////////////////////////////////////////////////// + void SetTimerTrigger(FIT_TIMER_TRIGGER timerTrigger) + { + SetFieldENUMValue(3, timerTrigger, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIMER_TRIGGER); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of course_point_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCoursePointIndexValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COURSE_POINT_INDEX ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COURSE_POINT_INDEX); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns course_point_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetCoursePointIndex(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COURSE_POINT_INDEX); + } + + /////////////////////////////////////////////////////////////////////// + // Set course_point_index field + /////////////////////////////////////////////////////////////////////// + void SetCoursePointIndex(FIT_MESSAGE_INDEX coursePointIndex) + { + SetFieldUINT16Value(3, coursePointIndex, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COURSE_POINT_INDEX); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatteryLevelValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_BATTERY_LEVEL ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_BATTERY_LEVEL); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns battery_level field + // Units: V + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBatteryLevel(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_BATTERY_LEVEL); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_level field + // Units: V + /////////////////////////////////////////////////////////////////////// + void SetBatteryLevel(FIT_FLOAT32 batteryLevel) + { + SetFieldFLOAT32Value(3, batteryLevel, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_BATTERY_LEVEL); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of virtual_partner_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVirtualPartnerSpeedValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_VIRTUAL_PARTNER_SPEED ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_VIRTUAL_PARTNER_SPEED); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns virtual_partner_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVirtualPartnerSpeed(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_VIRTUAL_PARTNER_SPEED); + } + + /////////////////////////////////////////////////////////////////////// + // Set virtual_partner_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetVirtualPartnerSpeed(FIT_FLOAT32 virtualPartnerSpeed) + { + SetFieldFLOAT32Value(3, virtualPartnerSpeed, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_VIRTUAL_PARTNER_SPEED); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_high_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrHighAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_HIGH_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_HIGH_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns hr_high_alert field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHrHighAlert(void) const + { + return GetFieldUINT8Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_high_alert field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHrHighAlert(FIT_UINT8 hrHighAlert) + { + SetFieldUINT8Value(3, hrHighAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_low_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrLowAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_LOW_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_LOW_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns hr_low_alert field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHrLowAlert(void) const + { + return GetFieldUINT8Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_low_alert field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHrLowAlert(FIT_UINT8 hrLowAlert) + { + SetFieldUINT8Value(3, hrLowAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_HR_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_high_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedHighAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_HIGH_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_HIGH_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns speed_high_alert field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeedHighAlert(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_high_alert field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSpeedHighAlert(FIT_FLOAT32 speedHighAlert) + { + SetFieldFLOAT32Value(3, speedHighAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_low_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedLowAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_LOW_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_LOW_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns speed_low_alert field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeedLowAlert(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_low_alert field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSpeedLowAlert(FIT_FLOAT32 speedLowAlert) + { + SetFieldFLOAT32Value(3, speedLowAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPEED_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cad_high_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCadHighAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_HIGH_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_HIGH_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns cad_high_alert field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCadHighAlert(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set cad_high_alert field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetCadHighAlert(FIT_UINT16 cadHighAlert) + { + SetFieldUINT16Value(3, cadHighAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cad_low_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCadLowAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_LOW_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_LOW_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns cad_low_alert field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCadLowAlert(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set cad_low_alert field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetCadLowAlert(FIT_UINT16 cadLowAlert) + { + SetFieldUINT16Value(3, cadLowAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CAD_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power_high_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerHighAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_HIGH_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_HIGH_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns power_high_alert field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPowerHighAlert(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set power_high_alert field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetPowerHighAlert(FIT_UINT16 powerHighAlert) + { + SetFieldUINT16Value(3, powerHighAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_HIGH_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power_low_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerLowAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_LOW_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_LOW_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns power_low_alert field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPowerLowAlert(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set power_low_alert field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetPowerLowAlert(FIT_UINT16 powerLowAlert) + { + SetFieldUINT16Value(3, powerLowAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_POWER_LOW_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_duration_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeDurationAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIME_DURATION_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIME_DURATION_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns time_duration_alert field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeDurationAlert(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIME_DURATION_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_duration_alert field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeDurationAlert(FIT_FLOAT32 timeDurationAlert) + { + SetFieldFLOAT32Value(3, timeDurationAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_TIME_DURATION_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance_duration_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceDurationAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DISTANCE_DURATION_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DISTANCE_DURATION_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns distance_duration_alert field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDistanceDurationAlert(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DISTANCE_DURATION_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance_duration_alert field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDistanceDurationAlert(FIT_FLOAT32 distanceDurationAlert) + { + SetFieldFLOAT32Value(3, distanceDurationAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DISTANCE_DURATION_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calorie_duration_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalorieDurationAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CALORIE_DURATION_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CALORIE_DURATION_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns calorie_duration_alert field + // Units: calories + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCalorieDurationAlert(void) const + { + return GetFieldUINT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CALORIE_DURATION_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set calorie_duration_alert field + // Units: calories + /////////////////////////////////////////////////////////////////////// + void SetCalorieDurationAlert(FIT_UINT32 calorieDurationAlert) + { + SetFieldUINT32Value(3, calorieDurationAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_CALORIE_DURATION_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fitness_equipment_state field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFitnessEquipmentStateValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_FITNESS_EQUIPMENT_STATE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_FITNESS_EQUIPMENT_STATE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns fitness_equipment_state field + /////////////////////////////////////////////////////////////////////// + FIT_FITNESS_EQUIPMENT_STATE GetFitnessEquipmentState(void) const + { + return GetFieldENUMValue(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_FITNESS_EQUIPMENT_STATE); + } + + /////////////////////////////////////////////////////////////////////// + // Set fitness_equipment_state field + /////////////////////////////////////////////////////////////////////// + void SetFitnessEquipmentState(FIT_FITNESS_EQUIPMENT_STATE fitnessEquipmentState) + { + SetFieldENUMValue(3, fitnessEquipmentState, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_FITNESS_EQUIPMENT_STATE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport_point field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportPointValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPORT_POINT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPORT_POINT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns sport_point field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSportPoint(void) const + { + return GetFieldUINT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPORT_POINT); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport_point field + /////////////////////////////////////////////////////////////////////// + void SetSportPoint(FIT_UINT32 sportPoint) + { + SetFieldUINT32Value(3, sportPoint, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_SPORT_POINT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gear_change_data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGearChangeDataValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_GEAR_CHANGE_DATA ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_GEAR_CHANGE_DATA); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns gear_change_data field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetGearChangeData(void) const + { + return GetFieldUINT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_GEAR_CHANGE_DATA); + } + + /////////////////////////////////////////////////////////////////////// + // Set gear_change_data field + /////////////////////////////////////////////////////////////////////// + void SetGearChangeData(FIT_UINT32 gearChangeData) + { + SetFieldUINT32Value(3, gearChangeData, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_GEAR_CHANGE_DATA); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rider_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRiderPositionValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RIDER_POSITION ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RIDER_POSITION); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns rider_position field + // Comment: Indicates the rider position value. + /////////////////////////////////////////////////////////////////////// + FIT_RIDER_POSITION_TYPE GetRiderPosition(void) const + { + return GetFieldENUMValue(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RIDER_POSITION); + } + + /////////////////////////////////////////////////////////////////////// + // Set rider_position field + // Comment: Indicates the rider position value. + /////////////////////////////////////////////////////////////////////// + void SetRiderPosition(FIT_RIDER_POSITION_TYPE riderPosition) + { + SetFieldENUMValue(3, riderPosition, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RIDER_POSITION); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of comm_timeout field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCommTimeoutValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COMM_TIMEOUT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COMM_TIMEOUT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns comm_timeout field + /////////////////////////////////////////////////////////////////////// + FIT_COMM_TIMEOUT_TYPE GetCommTimeout(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COMM_TIMEOUT); + } + + /////////////////////////////////////////////////////////////////////// + // Set comm_timeout field + /////////////////////////////////////////////////////////////////////// + void SetCommTimeout(FIT_COMM_TIMEOUT_TYPE commTimeout) + { + SetFieldUINT16Value(3, commTimeout, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_COMM_TIMEOUT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DIVE_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DIVE_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns dive_alert field + /////////////////////////////////////////////////////////////////////// + FIT_DIVE_ALERT GetDiveAlert(void) const + { + return GetFieldENUMValue(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DIVE_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_alert field + /////////////////////////////////////////////////////////////////////// + void SetDiveAlert(FIT_DIVE_ALERT diveAlert) + { + SetFieldENUMValue(3, diveAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_DIVE_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_activity_detect_duration field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoActivityDetectDurationValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_AUTO_ACTIVITY_DETECT_DURATION ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_AUTO_ACTIVITY_DETECT_DURATION); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns auto_activity_detect_duration field + // Units: min + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAutoActivityDetectDuration(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_AUTO_ACTIVITY_DETECT_DURATION); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_activity_detect_duration field + // Units: min + /////////////////////////////////////////////////////////////////////// + void SetAutoActivityDetectDuration(FIT_UINT16 autoActivityDetectDuration) + { + SetFieldUINT16Value(3, autoActivityDetectDuration, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_AUTO_ACTIVITY_DETECT_DURATION); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of radar_threat_alert field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRadarThreatAlertValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RADAR_THREAT_ALERT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RADAR_THREAT_ALERT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns radar_threat_alert field + // Comment: The first byte is the radar_threat_level_max, the second byte is the radar_threat_count, third bytes is the average approach speed, and the 4th byte is the max approach speed + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetRadarThreatAlert(void) const + { + return GetFieldUINT32Value(3, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RADAR_THREAT_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Set radar_threat_alert field + // Comment: The first byte is the radar_threat_level_max, the second byte is the radar_threat_count, third bytes is the average approach speed, and the 4th byte is the max approach speed + /////////////////////////////////////////////////////////////////////// + void SetRadarThreatAlert(FIT_UINT32 radarThreatAlert) + { + SetFieldUINT32Value(3, radarThreatAlert, 0, (FIT_UINT16) Profile::EVENT_MESG_DATA_FIELD_RADAR_THREAT_ALERT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_group field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventGroupValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_group field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventGroup(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_group field + /////////////////////////////////////////////////////////////////////// + void SetEventGroup(FIT_UINT8 eventGroup) + { + SetFieldUINT8Value(4, eventGroup, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScoreValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns score field + // Comment: Do not populate directly. Autogenerated by decoder for sport_point subfield components + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetScore(void) const + { + return GetFieldUINT16Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set score field + // Comment: Do not populate directly. Autogenerated by decoder for sport_point subfield components + /////////////////////////////////////////////////////////////////////// + void SetScore(FIT_UINT16 score) + { + SetFieldUINT16Value(7, score, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of opponent_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOpponentScoreValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns opponent_score field + // Comment: Do not populate directly. Autogenerated by decoder for sport_point subfield components + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetOpponentScore(void) const + { + return GetFieldUINT16Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set opponent_score field + // Comment: Do not populate directly. Autogenerated by decoder for sport_point subfield components + /////////////////////////////////////////////////////////////////////// + void SetOpponentScore(FIT_UINT16 opponentScore) + { + SetFieldUINT16Value(8, opponentScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of front_gear_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFrontGearNumValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns front_gear_num field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Front gear number. 1 is innermost. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetFrontGearNum(void) const + { + return GetFieldUINT8ZValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set front_gear_num field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Front gear number. 1 is innermost. + /////////////////////////////////////////////////////////////////////// + void SetFrontGearNum(FIT_UINT8Z frontGearNum) + { + SetFieldUINT8ZValue(9, frontGearNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of front_gear field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFrontGearValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns front_gear field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Number of front teeth. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetFrontGear(void) const + { + return GetFieldUINT8ZValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set front_gear field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Number of front teeth. + /////////////////////////////////////////////////////////////////////// + void SetFrontGear(FIT_UINT8Z frontGear) + { + SetFieldUINT8ZValue(10, frontGear, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rear_gear_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRearGearNumValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rear_gear_num field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Rear gear number. 1 is innermost. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetRearGearNum(void) const + { + return GetFieldUINT8ZValue(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rear_gear_num field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Rear gear number. 1 is innermost. + /////////////////////////////////////////////////////////////////////// + void SetRearGearNum(FIT_UINT8Z rearGearNum) + { + SetFieldUINT8ZValue(11, rearGearNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rear_gear field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRearGearValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rear_gear field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Number of rear teeth. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetRearGear(void) const + { + return GetFieldUINT8ZValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rear_gear field + // Comment: Do not populate directly. Autogenerated by decoder for gear_change subfield components. Number of rear teeth. + /////////////////////////////////////////////////////////////////////// + void SetRearGear(FIT_UINT8Z rearGear) + { + SetFieldUINT8ZValue(12, rearGear, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIndexValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_index field + /////////////////////////////////////////////////////////////////////// + FIT_DEVICE_INDEX GetDeviceIndex(void) const + { + return GetFieldUINT8Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_index field + /////////////////////////////////////////////////////////////////////// + void SetDeviceIndex(FIT_DEVICE_INDEX deviceIndex) + { + SetFieldUINT8Value(13, deviceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityTypeValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_type field + // Comment: Activity Type associated with an auto_activity_detect event + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_TYPE GetActivityType(void) const + { + return GetFieldENUMValue(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_type field + // Comment: Activity Type associated with an auto_activity_detect event + /////////////////////////////////////////////////////////////////////// + void SetActivityType(FIT_ACTIVITY_TYPE activityType) + { + SetFieldENUMValue(14, activityType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimestampValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_timestamp field + // Units: s + // Comment: Timestamp of when the event started + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTimestamp(void) const + { + return GetFieldUINT32Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_timestamp field + // Units: s + // Comment: Timestamp of when the event started + /////////////////////////////////////////////////////////////////////// + void SetStartTimestamp(FIT_DATE_TIME startTimestamp) + { + SetFieldUINT32Value(15, startTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of auto_activity_detect_start_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAutoActivityDetectStartTimestampValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::EVENT_MESG_START_TIMESTAMP_FIELD_AUTO_ACTIVITY_DETECT_START_TIMESTAMP ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::EVENT_MESG_START_TIMESTAMP_FIELD_AUTO_ACTIVITY_DETECT_START_TIMESTAMP); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns auto_activity_detect_start_timestamp field + // Units: s + // Comment: Auto Activity Detect Start Timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetAutoActivityDetectStartTimestamp(void) const + { + return GetFieldUINT32Value(15, 0, (FIT_UINT16) Profile::EVENT_MESG_START_TIMESTAMP_FIELD_AUTO_ACTIVITY_DETECT_START_TIMESTAMP); + } + + /////////////////////////////////////////////////////////////////////// + // Set auto_activity_detect_start_timestamp field + // Units: s + // Comment: Auto Activity Detect Start Timestamp. + /////////////////////////////////////////////////////////////////////// + void SetAutoActivityDetectStartTimestamp(FIT_DATE_TIME autoActivityDetectStartTimestamp) + { + SetFieldUINT32Value(15, autoActivityDetectStartTimestamp, 0, (FIT_UINT16) Profile::EVENT_MESG_START_TIMESTAMP_FIELD_AUTO_ACTIVITY_DETECT_START_TIMESTAMP); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of radar_threat_level_max field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRadarThreatLevelMaxValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns radar_threat_level_max field + // Comment: Do not populate directly. Autogenerated by decoder for threat_alert subfield components. + /////////////////////////////////////////////////////////////////////// + FIT_RADAR_THREAT_LEVEL_TYPE GetRadarThreatLevelMax(void) const + { + return GetFieldENUMValue(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set radar_threat_level_max field + // Comment: Do not populate directly. Autogenerated by decoder for threat_alert subfield components. + /////////////////////////////////////////////////////////////////////// + void SetRadarThreatLevelMax(FIT_RADAR_THREAT_LEVEL_TYPE radarThreatLevelMax) + { + SetFieldENUMValue(21, radarThreatLevelMax, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of radar_threat_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRadarThreatCountValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns radar_threat_count field + // Comment: Do not populate directly. Autogenerated by decoder for threat_alert subfield components. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRadarThreatCount(void) const + { + return GetFieldUINT8Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set radar_threat_count field + // Comment: Do not populate directly. Autogenerated by decoder for threat_alert subfield components. + /////////////////////////////////////////////////////////////////////// + void SetRadarThreatCount(FIT_UINT8 radarThreatCount) + { + SetFieldUINT8Value(22, radarThreatCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of radar_threat_avg_approach_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRadarThreatAvgApproachSpeedValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns radar_threat_avg_approach_speed field + // Units: m/s + // Comment: Do not populate directly. Autogenerated by decoder for radar_threat_alert subfield components + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRadarThreatAvgApproachSpeed(void) const + { + return GetFieldFLOAT32Value(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set radar_threat_avg_approach_speed field + // Units: m/s + // Comment: Do not populate directly. Autogenerated by decoder for radar_threat_alert subfield components + /////////////////////////////////////////////////////////////////////// + void SetRadarThreatAvgApproachSpeed(FIT_FLOAT32 radarThreatAvgApproachSpeed) + { + SetFieldFLOAT32Value(23, radarThreatAvgApproachSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of radar_threat_max_approach_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRadarThreatMaxApproachSpeedValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns radar_threat_max_approach_speed field + // Units: m/s + // Comment: Do not populate directly. Autogenerated by decoder for radar_threat_alert subfield components + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRadarThreatMaxApproachSpeed(void) const + { + return GetFieldFLOAT32Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set radar_threat_max_approach_speed field + // Units: m/s + // Comment: Do not populate directly. Autogenerated by decoder for radar_threat_alert subfield components + /////////////////////////////////////////////////////////////////////// + void SetRadarThreatMaxApproachSpeed(FIT_FLOAT32 radarThreatMaxApproachSpeed) + { + SetFieldFLOAT32Value(24, radarThreatMaxApproachSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_EVENT_MESG_HPP) diff --git a/fit_event_mesg_listener.hpp b/fit_event_mesg_listener.hpp new file mode 100644 index 0000000..e347eb9 --- /dev/null +++ b/fit_event_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EVENT_MESG_LISTENER_HPP) +#define FIT_EVENT_MESG_LISTENER_HPP + +#include "fit_event_mesg.hpp" + +namespace fit +{ + +class EventMesgListener +{ +public: + virtual ~EventMesgListener() {} + virtual void OnMesg(EventMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_EVENT_MESG_LISTENER_HPP) diff --git a/fit_exd_data_concept_configuration_mesg.hpp b/fit_exd_data_concept_configuration_mesg.hpp new file mode 100644 index 0000000..18423fd --- /dev/null +++ b/fit_exd_data_concept_configuration_mesg.hpp @@ -0,0 +1,394 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXD_DATA_CONCEPT_CONFIGURATION_MESG_HPP) +#define FIT_EXD_DATA_CONCEPT_CONFIGURATION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ExdDataConceptConfigurationMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 ScreenIndex = 0; + static const FIT_UINT8 ConceptField = 1; + static const FIT_UINT8 FieldId = 2; + static const FIT_UINT8 ConceptIndex = 3; + static const FIT_UINT8 DataPage = 4; + static const FIT_UINT8 ConceptKey = 5; + static const FIT_UINT8 Scaling = 6; + static const FIT_UINT8 DataUnits = 8; + static const FIT_UINT8 Qualifier = 9; + static const FIT_UINT8 Descriptor = 10; + static const FIT_UINT8 IsSigned = 11; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ExdDataConceptConfigurationMesg(void) : Mesg(Profile::MESG_EXD_DATA_CONCEPT_CONFIGURATION) + { + } + + ExdDataConceptConfigurationMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of screen_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScreenIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns screen_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetScreenIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set screen_index field + /////////////////////////////////////////////////////////////////////// + void SetScreenIndex(FIT_UINT8 screenIndex) + { + SetFieldUINT8Value(0, screenIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of concept_field field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConceptFieldValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns concept_field field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetConceptField(void) const + { + return GetFieldBYTEValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set concept_field field + /////////////////////////////////////////////////////////////////////// + void SetConceptField(FIT_BYTE conceptField) + { + SetFieldBYTEValue(1, conceptField, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldIdValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFieldId(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_id field + /////////////////////////////////////////////////////////////////////// + void SetFieldId(FIT_UINT8 fieldId) + { + SetFieldUINT8Value(2, fieldId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of concept_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConceptIndexValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns concept_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetConceptIndex(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set concept_index field + /////////////////////////////////////////////////////////////////////// + void SetConceptIndex(FIT_UINT8 conceptIndex) + { + SetFieldUINT8Value(3, conceptIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data_page field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataPageValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data_page field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDataPage(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data_page field + /////////////////////////////////////////////////////////////////////// + void SetDataPage(FIT_UINT8 dataPage) + { + SetFieldUINT8Value(4, dataPage, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of concept_key field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConceptKeyValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns concept_key field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetConceptKey(void) const + { + return GetFieldUINT8Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set concept_key field + /////////////////////////////////////////////////////////////////////// + void SetConceptKey(FIT_UINT8 conceptKey) + { + SetFieldUINT8Value(5, conceptKey, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of scaling field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScalingValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns scaling field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetScaling(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set scaling field + /////////////////////////////////////////////////////////////////////// + void SetScaling(FIT_UINT8 scaling) + { + SetFieldUINT8Value(6, scaling, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data_units field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataUnitsValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data_units field + /////////////////////////////////////////////////////////////////////// + FIT_EXD_DATA_UNITS GetDataUnits(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data_units field + /////////////////////////////////////////////////////////////////////// + void SetDataUnits(FIT_EXD_DATA_UNITS dataUnits) + { + SetFieldENUMValue(8, dataUnits, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of qualifier field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsQualifierValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns qualifier field + /////////////////////////////////////////////////////////////////////// + FIT_EXD_QUALIFIERS GetQualifier(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set qualifier field + /////////////////////////////////////////////////////////////////////// + void SetQualifier(FIT_EXD_QUALIFIERS qualifier) + { + SetFieldENUMValue(9, qualifier, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of descriptor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDescriptorValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns descriptor field + /////////////////////////////////////////////////////////////////////// + FIT_EXD_DESCRIPTORS GetDescriptor(void) const + { + return GetFieldENUMValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set descriptor field + /////////////////////////////////////////////////////////////////////// + void SetDescriptor(FIT_EXD_DESCRIPTORS descriptor) + { + SetFieldENUMValue(10, descriptor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of is_signed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIsSignedValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns is_signed field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetIsSigned(void) const + { + return GetFieldENUMValue(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set is_signed field + /////////////////////////////////////////////////////////////////////// + void SetIsSigned(FIT_BOOL isSigned) + { + SetFieldENUMValue(11, isSigned, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_EXD_DATA_CONCEPT_CONFIGURATION_MESG_HPP) diff --git a/fit_exd_data_concept_configuration_mesg_listener.hpp b/fit_exd_data_concept_configuration_mesg_listener.hpp new file mode 100644 index 0000000..6229a4c --- /dev/null +++ b/fit_exd_data_concept_configuration_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXD_DATA_CONCEPT_CONFIGURATION_MESG_LISTENER_HPP) +#define FIT_EXD_DATA_CONCEPT_CONFIGURATION_MESG_LISTENER_HPP + +#include "fit_exd_data_concept_configuration_mesg.hpp" + +namespace fit +{ + +class ExdDataConceptConfigurationMesgListener +{ +public: + virtual ~ExdDataConceptConfigurationMesgListener() {} + virtual void OnMesg(ExdDataConceptConfigurationMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_EXD_DATA_CONCEPT_CONFIGURATION_MESG_LISTENER_HPP) diff --git a/fit_exd_data_field_configuration_mesg.hpp b/fit_exd_data_field_configuration_mesg.hpp new file mode 100644 index 0000000..7235f74 --- /dev/null +++ b/fit_exd_data_field_configuration_mesg.hpp @@ -0,0 +1,242 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXD_DATA_FIELD_CONFIGURATION_MESG_HPP) +#define FIT_EXD_DATA_FIELD_CONFIGURATION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ExdDataFieldConfigurationMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 ScreenIndex = 0; + static const FIT_UINT8 ConceptField = 1; + static const FIT_UINT8 FieldId = 2; + static const FIT_UINT8 ConceptCount = 3; + static const FIT_UINT8 DisplayType = 4; + static const FIT_UINT8 Title = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ExdDataFieldConfigurationMesg(void) : Mesg(Profile::MESG_EXD_DATA_FIELD_CONFIGURATION) + { + } + + ExdDataFieldConfigurationMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of screen_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScreenIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns screen_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetScreenIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set screen_index field + /////////////////////////////////////////////////////////////////////// + void SetScreenIndex(FIT_UINT8 screenIndex) + { + SetFieldUINT8Value(0, screenIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of concept_field field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConceptFieldValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns concept_field field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetConceptField(void) const + { + return GetFieldBYTEValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set concept_field field + /////////////////////////////////////////////////////////////////////// + void SetConceptField(FIT_BYTE conceptField) + { + SetFieldBYTEValue(1, conceptField, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldIdValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFieldId(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_id field + /////////////////////////////////////////////////////////////////////// + void SetFieldId(FIT_UINT8 fieldId) + { + SetFieldUINT8Value(2, fieldId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of concept_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConceptCountValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns concept_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetConceptCount(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set concept_count field + /////////////////////////////////////////////////////////////////////// + void SetConceptCount(FIT_UINT8 conceptCount) + { + SetFieldUINT8Value(3, conceptCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of display_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDisplayTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns display_type field + /////////////////////////////////////////////////////////////////////// + FIT_EXD_DISPLAY_TYPE GetDisplayType(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set display_type field + /////////////////////////////////////////////////////////////////////// + void SetDisplayType(FIT_EXD_DISPLAY_TYPE displayType) + { + SetFieldENUMValue(4, displayType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of title + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTitle(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of title field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTitleValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns title field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetTitle(FIT_UINT8 index) const + { + return GetFieldSTRINGValue(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set title field + /////////////////////////////////////////////////////////////////////// + void SetTitle(FIT_UINT8 index, FIT_WSTRING title) + { + SetFieldSTRINGValue(5, title, index); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_EXD_DATA_FIELD_CONFIGURATION_MESG_HPP) diff --git a/fit_exd_data_field_configuration_mesg_listener.hpp b/fit_exd_data_field_configuration_mesg_listener.hpp new file mode 100644 index 0000000..18ca7f9 --- /dev/null +++ b/fit_exd_data_field_configuration_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXD_DATA_FIELD_CONFIGURATION_MESG_LISTENER_HPP) +#define FIT_EXD_DATA_FIELD_CONFIGURATION_MESG_LISTENER_HPP + +#include "fit_exd_data_field_configuration_mesg.hpp" + +namespace fit +{ + +class ExdDataFieldConfigurationMesgListener +{ +public: + virtual ~ExdDataFieldConfigurationMesgListener() {} + virtual void OnMesg(ExdDataFieldConfigurationMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_EXD_DATA_FIELD_CONFIGURATION_MESG_LISTENER_HPP) diff --git a/fit_exd_screen_configuration_mesg.hpp b/fit_exd_screen_configuration_mesg.hpp new file mode 100644 index 0000000..dbb73a0 --- /dev/null +++ b/fit_exd_screen_configuration_mesg.hpp @@ -0,0 +1,172 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXD_SCREEN_CONFIGURATION_MESG_HPP) +#define FIT_EXD_SCREEN_CONFIGURATION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ExdScreenConfigurationMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 ScreenIndex = 0; + static const FIT_UINT8 FieldCount = 1; + static const FIT_UINT8 Layout = 2; + static const FIT_UINT8 ScreenEnabled = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ExdScreenConfigurationMesg(void) : Mesg(Profile::MESG_EXD_SCREEN_CONFIGURATION) + { + } + + ExdScreenConfigurationMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of screen_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScreenIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns screen_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetScreenIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set screen_index field + /////////////////////////////////////////////////////////////////////// + void SetScreenIndex(FIT_UINT8 screenIndex) + { + SetFieldUINT8Value(0, screenIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldCountValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_count field + // Comment: number of fields in screen + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFieldCount(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_count field + // Comment: number of fields in screen + /////////////////////////////////////////////////////////////////////// + void SetFieldCount(FIT_UINT8 fieldCount) + { + SetFieldUINT8Value(1, fieldCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of layout field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLayoutValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns layout field + /////////////////////////////////////////////////////////////////////// + FIT_EXD_LAYOUT GetLayout(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set layout field + /////////////////////////////////////////////////////////////////////// + void SetLayout(FIT_EXD_LAYOUT layout) + { + SetFieldENUMValue(2, layout, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of screen_enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScreenEnabledValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns screen_enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetScreenEnabled(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set screen_enabled field + /////////////////////////////////////////////////////////////////////// + void SetScreenEnabled(FIT_BOOL screenEnabled) + { + SetFieldENUMValue(3, screenEnabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_EXD_SCREEN_CONFIGURATION_MESG_HPP) diff --git a/fit_exd_screen_configuration_mesg_listener.hpp b/fit_exd_screen_configuration_mesg_listener.hpp new file mode 100644 index 0000000..14c686d --- /dev/null +++ b/fit_exd_screen_configuration_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXD_SCREEN_CONFIGURATION_MESG_LISTENER_HPP) +#define FIT_EXD_SCREEN_CONFIGURATION_MESG_LISTENER_HPP + +#include "fit_exd_screen_configuration_mesg.hpp" + +namespace fit +{ + +class ExdScreenConfigurationMesgListener +{ +public: + virtual ~ExdScreenConfigurationMesgListener() {} + virtual void OnMesg(ExdScreenConfigurationMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_EXD_SCREEN_CONFIGURATION_MESG_LISTENER_HPP) diff --git a/fit_exercise_title_mesg.hpp b/fit_exercise_title_mesg.hpp new file mode 100644 index 0000000..ede8c0f --- /dev/null +++ b/fit_exercise_title_mesg.hpp @@ -0,0 +1,178 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXERCISE_TITLE_MESG_HPP) +#define FIT_EXERCISE_TITLE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ExerciseTitleMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 ExerciseCategory = 0; + static const FIT_UINT8 ExerciseName = 1; + static const FIT_UINT8 WktStepName = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ExerciseTitleMesg(void) : Mesg(Profile::MESG_EXERCISE_TITLE) + { + } + + ExerciseTitleMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of exercise_category field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsExerciseCategoryValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns exercise_category field + /////////////////////////////////////////////////////////////////////// + FIT_EXERCISE_CATEGORY GetExerciseCategory(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set exercise_category field + /////////////////////////////////////////////////////////////////////// + void SetExerciseCategory(FIT_EXERCISE_CATEGORY exerciseCategory) + { + SetFieldUINT16Value(0, exerciseCategory, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of exercise_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsExerciseNameValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns exercise_name field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetExerciseName(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set exercise_name field + /////////////////////////////////////////////////////////////////////// + void SetExerciseName(FIT_UINT16 exerciseName) + { + SetFieldUINT16Value(1, exerciseName, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of wkt_step_name + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumWktStepName(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_step_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktStepNameValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_step_name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetWktStepName(FIT_UINT8 index) const + { + return GetFieldSTRINGValue(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_step_name field + /////////////////////////////////////////////////////////////////////// + void SetWktStepName(FIT_UINT8 index, FIT_WSTRING wktStepName) + { + SetFieldSTRINGValue(2, wktStepName, index); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_EXERCISE_TITLE_MESG_HPP) diff --git a/fit_exercise_title_mesg_listener.hpp b/fit_exercise_title_mesg_listener.hpp new file mode 100644 index 0000000..d3ce40b --- /dev/null +++ b/fit_exercise_title_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_EXERCISE_TITLE_MESG_LISTENER_HPP) +#define FIT_EXERCISE_TITLE_MESG_LISTENER_HPP + +#include "fit_exercise_title_mesg.hpp" + +namespace fit +{ + +class ExerciseTitleMesgListener +{ +public: + virtual ~ExerciseTitleMesgListener() {} + virtual void OnMesg(ExerciseTitleMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_EXERCISE_TITLE_MESG_LISTENER_HPP) diff --git a/fit_factory.cpp b/fit_factory.cpp new file mode 100644 index 0000000..34437c1 --- /dev/null +++ b/fit_factory.cpp @@ -0,0 +1,523 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_factory.hpp" +#include "fit_file_id_mesg.hpp" +#include "fit_file_creator_mesg.hpp" +#include "fit_timestamp_correlation_mesg.hpp" +#include "fit_software_mesg.hpp" +#include "fit_slave_device_mesg.hpp" +#include "fit_capabilities_mesg.hpp" +#include "fit_file_capabilities_mesg.hpp" +#include "fit_mesg_capabilities_mesg.hpp" +#include "fit_field_capabilities_mesg.hpp" +#include "fit_device_settings_mesg.hpp" +#include "fit_user_profile_mesg.hpp" +#include "fit_hrm_profile_mesg.hpp" +#include "fit_sdm_profile_mesg.hpp" +#include "fit_bike_profile_mesg.hpp" +#include "fit_connectivity_mesg.hpp" +#include "fit_watchface_settings_mesg.hpp" +#include "fit_ohr_settings_mesg.hpp" +#include "fit_time_in_zone_mesg.hpp" +#include "fit_zones_target_mesg.hpp" +#include "fit_sport_mesg.hpp" +#include "fit_hr_zone_mesg.hpp" +#include "fit_speed_zone_mesg.hpp" +#include "fit_cadence_zone_mesg.hpp" +#include "fit_power_zone_mesg.hpp" +#include "fit_met_zone_mesg.hpp" +#include "fit_training_settings_mesg.hpp" +#include "fit_dive_settings_mesg.hpp" +#include "fit_dive_alarm_mesg.hpp" +#include "fit_dive_apnea_alarm_mesg.hpp" +#include "fit_dive_gas_mesg.hpp" +#include "fit_goal_mesg.hpp" +#include "fit_activity_mesg.hpp" +#include "fit_session_mesg.hpp" +#include "fit_lap_mesg.hpp" +#include "fit_length_mesg.hpp" +#include "fit_record_mesg.hpp" +#include "fit_event_mesg.hpp" +#include "fit_device_info_mesg.hpp" +#include "fit_device_aux_battery_info_mesg.hpp" +#include "fit_training_file_mesg.hpp" +#include "fit_weather_conditions_mesg.hpp" +#include "fit_weather_alert_mesg.hpp" +#include "fit_gps_metadata_mesg.hpp" +#include "fit_camera_event_mesg.hpp" +#include "fit_gyroscope_data_mesg.hpp" +#include "fit_accelerometer_data_mesg.hpp" +#include "fit_magnetometer_data_mesg.hpp" +#include "fit_barometer_data_mesg.hpp" +#include "fit_three_d_sensor_calibration_mesg.hpp" +#include "fit_one_d_sensor_calibration_mesg.hpp" +#include "fit_video_frame_mesg.hpp" +#include "fit_obdii_data_mesg.hpp" +#include "fit_nmea_sentence_mesg.hpp" +#include "fit_aviation_attitude_mesg.hpp" +#include "fit_video_mesg.hpp" +#include "fit_video_title_mesg.hpp" +#include "fit_video_description_mesg.hpp" +#include "fit_video_clip_mesg.hpp" +#include "fit_set_mesg.hpp" +#include "fit_jump_mesg.hpp" +#include "fit_split_mesg.hpp" +#include "fit_split_summary_mesg.hpp" +#include "fit_climb_pro_mesg.hpp" +#include "fit_field_description_mesg.hpp" +#include "fit_developer_data_id_mesg.hpp" +#include "fit_course_mesg.hpp" +#include "fit_course_point_mesg.hpp" +#include "fit_segment_id_mesg.hpp" +#include "fit_segment_leaderboard_entry_mesg.hpp" +#include "fit_segment_point_mesg.hpp" +#include "fit_segment_lap_mesg.hpp" +#include "fit_segment_file_mesg.hpp" +#include "fit_workout_mesg.hpp" +#include "fit_workout_session_mesg.hpp" +#include "fit_workout_step_mesg.hpp" +#include "fit_exercise_title_mesg.hpp" +#include "fit_schedule_mesg.hpp" +#include "fit_totals_mesg.hpp" +#include "fit_weight_scale_mesg.hpp" +#include "fit_blood_pressure_mesg.hpp" +#include "fit_monitoring_info_mesg.hpp" +#include "fit_monitoring_mesg.hpp" +#include "fit_monitoring_hr_data_mesg.hpp" +#include "fit_spo2_data_mesg.hpp" +#include "fit_hr_mesg.hpp" +#include "fit_stress_level_mesg.hpp" +#include "fit_max_met_data_mesg.hpp" +#include "fit_hsa_body_battery_data_mesg.hpp" +#include "fit_hsa_event_mesg.hpp" +#include "fit_hsa_accelerometer_data_mesg.hpp" +#include "fit_hsa_gyroscope_data_mesg.hpp" +#include "fit_hsa_step_data_mesg.hpp" +#include "fit_hsa_spo2_data_mesg.hpp" +#include "fit_hsa_stress_data_mesg.hpp" +#include "fit_hsa_respiration_data_mesg.hpp" +#include "fit_hsa_heart_rate_data_mesg.hpp" +#include "fit_hsa_configuration_data_mesg.hpp" +#include "fit_hsa_wrist_temperature_data_mesg.hpp" +#include "fit_memo_glob_mesg.hpp" +#include "fit_sleep_level_mesg.hpp" +#include "fit_ant_channel_id_mesg.hpp" +#include "fit_ant_rx_mesg.hpp" +#include "fit_ant_tx_mesg.hpp" +#include "fit_exd_screen_configuration_mesg.hpp" +#include "fit_exd_data_field_configuration_mesg.hpp" +#include "fit_exd_data_concept_configuration_mesg.hpp" +#include "fit_dive_summary_mesg.hpp" +#include "fit_aad_accel_features_mesg.hpp" +#include "fit_hrv_mesg.hpp" +#include "fit_beat_intervals_mesg.hpp" +#include "fit_hrv_status_summary_mesg.hpp" +#include "fit_hrv_value_mesg.hpp" +#include "fit_raw_bbi_mesg.hpp" +#include "fit_respiration_rate_mesg.hpp" +#include "fit_chrono_shot_session_mesg.hpp" +#include "fit_chrono_shot_data_mesg.hpp" +#include "fit_tank_update_mesg.hpp" +#include "fit_tank_summary_mesg.hpp" +#include "fit_sleep_assessment_mesg.hpp" +#include "fit_sleep_disruption_severity_period_mesg.hpp" +#include "fit_sleep_disruption_overnight_severity_mesg.hpp" +#include "fit_skin_temp_overnight_mesg.hpp" +#include "fit_pad_mesg.hpp" + +namespace fit +{ + +Mesg Factory::CreateMesg(Mesg mesg) +{ + switch (mesg.GetNum()) + { + + case FIT_MESG_NUM_FILE_ID: + return FileIdMesg(mesg); + + case FIT_MESG_NUM_FILE_CREATOR: + return FileCreatorMesg(mesg); + + case FIT_MESG_NUM_TIMESTAMP_CORRELATION: + return TimestampCorrelationMesg(mesg); + + case FIT_MESG_NUM_SOFTWARE: + return SoftwareMesg(mesg); + + case FIT_MESG_NUM_SLAVE_DEVICE: + return SlaveDeviceMesg(mesg); + + case FIT_MESG_NUM_CAPABILITIES: + return CapabilitiesMesg(mesg); + + case FIT_MESG_NUM_FILE_CAPABILITIES: + return FileCapabilitiesMesg(mesg); + + case FIT_MESG_NUM_MESG_CAPABILITIES: + return MesgCapabilitiesMesg(mesg); + + case FIT_MESG_NUM_FIELD_CAPABILITIES: + return FieldCapabilitiesMesg(mesg); + + case FIT_MESG_NUM_DEVICE_SETTINGS: + return DeviceSettingsMesg(mesg); + + case FIT_MESG_NUM_USER_PROFILE: + return UserProfileMesg(mesg); + + case FIT_MESG_NUM_HRM_PROFILE: + return HrmProfileMesg(mesg); + + case FIT_MESG_NUM_SDM_PROFILE: + return SdmProfileMesg(mesg); + + case FIT_MESG_NUM_BIKE_PROFILE: + return BikeProfileMesg(mesg); + + case FIT_MESG_NUM_CONNECTIVITY: + return ConnectivityMesg(mesg); + + case FIT_MESG_NUM_WATCHFACE_SETTINGS: + return WatchfaceSettingsMesg(mesg); + + case FIT_MESG_NUM_OHR_SETTINGS: + return OhrSettingsMesg(mesg); + + case FIT_MESG_NUM_TIME_IN_ZONE: + return TimeInZoneMesg(mesg); + + case FIT_MESG_NUM_ZONES_TARGET: + return ZonesTargetMesg(mesg); + + case FIT_MESG_NUM_SPORT: + return SportMesg(mesg); + + case FIT_MESG_NUM_HR_ZONE: + return HrZoneMesg(mesg); + + case FIT_MESG_NUM_SPEED_ZONE: + return SpeedZoneMesg(mesg); + + case FIT_MESG_NUM_CADENCE_ZONE: + return CadenceZoneMesg(mesg); + + case FIT_MESG_NUM_POWER_ZONE: + return PowerZoneMesg(mesg); + + case FIT_MESG_NUM_MET_ZONE: + return MetZoneMesg(mesg); + + case FIT_MESG_NUM_TRAINING_SETTINGS: + return TrainingSettingsMesg(mesg); + + case FIT_MESG_NUM_DIVE_SETTINGS: + return DiveSettingsMesg(mesg); + + case FIT_MESG_NUM_DIVE_ALARM: + return DiveAlarmMesg(mesg); + + case FIT_MESG_NUM_DIVE_APNEA_ALARM: + return DiveApneaAlarmMesg(mesg); + + case FIT_MESG_NUM_DIVE_GAS: + return DiveGasMesg(mesg); + + case FIT_MESG_NUM_GOAL: + return GoalMesg(mesg); + + case FIT_MESG_NUM_ACTIVITY: + return ActivityMesg(mesg); + + case FIT_MESG_NUM_SESSION: + return SessionMesg(mesg); + + case FIT_MESG_NUM_LAP: + return LapMesg(mesg); + + case FIT_MESG_NUM_LENGTH: + return LengthMesg(mesg); + + case FIT_MESG_NUM_RECORD: + return RecordMesg(mesg); + + case FIT_MESG_NUM_EVENT: + return EventMesg(mesg); + + case FIT_MESG_NUM_DEVICE_INFO: + return DeviceInfoMesg(mesg); + + case FIT_MESG_NUM_DEVICE_AUX_BATTERY_INFO: + return DeviceAuxBatteryInfoMesg(mesg); + + case FIT_MESG_NUM_TRAINING_FILE: + return TrainingFileMesg(mesg); + + case FIT_MESG_NUM_WEATHER_CONDITIONS: + return WeatherConditionsMesg(mesg); + + case FIT_MESG_NUM_WEATHER_ALERT: + return WeatherAlertMesg(mesg); + + case FIT_MESG_NUM_GPS_METADATA: + return GpsMetadataMesg(mesg); + + case FIT_MESG_NUM_CAMERA_EVENT: + return CameraEventMesg(mesg); + + case FIT_MESG_NUM_GYROSCOPE_DATA: + return GyroscopeDataMesg(mesg); + + case FIT_MESG_NUM_ACCELEROMETER_DATA: + return AccelerometerDataMesg(mesg); + + case FIT_MESG_NUM_MAGNETOMETER_DATA: + return MagnetometerDataMesg(mesg); + + case FIT_MESG_NUM_BAROMETER_DATA: + return BarometerDataMesg(mesg); + + case FIT_MESG_NUM_THREE_D_SENSOR_CALIBRATION: + return ThreeDSensorCalibrationMesg(mesg); + + case FIT_MESG_NUM_ONE_D_SENSOR_CALIBRATION: + return OneDSensorCalibrationMesg(mesg); + + case FIT_MESG_NUM_VIDEO_FRAME: + return VideoFrameMesg(mesg); + + case FIT_MESG_NUM_OBDII_DATA: + return ObdiiDataMesg(mesg); + + case FIT_MESG_NUM_NMEA_SENTENCE: + return NmeaSentenceMesg(mesg); + + case FIT_MESG_NUM_AVIATION_ATTITUDE: + return AviationAttitudeMesg(mesg); + + case FIT_MESG_NUM_VIDEO: + return VideoMesg(mesg); + + case FIT_MESG_NUM_VIDEO_TITLE: + return VideoTitleMesg(mesg); + + case FIT_MESG_NUM_VIDEO_DESCRIPTION: + return VideoDescriptionMesg(mesg); + + case FIT_MESG_NUM_VIDEO_CLIP: + return VideoClipMesg(mesg); + + case FIT_MESG_NUM_SET: + return SetMesg(mesg); + + case FIT_MESG_NUM_JUMP: + return JumpMesg(mesg); + + case FIT_MESG_NUM_SPLIT: + return SplitMesg(mesg); + + case FIT_MESG_NUM_SPLIT_SUMMARY: + return SplitSummaryMesg(mesg); + + case FIT_MESG_NUM_CLIMB_PRO: + return ClimbProMesg(mesg); + + case FIT_MESG_NUM_FIELD_DESCRIPTION: + return FieldDescriptionMesg(mesg); + + case FIT_MESG_NUM_DEVELOPER_DATA_ID: + return DeveloperDataIdMesg(mesg); + + case FIT_MESG_NUM_COURSE: + return CourseMesg(mesg); + + case FIT_MESG_NUM_COURSE_POINT: + return CoursePointMesg(mesg); + + case FIT_MESG_NUM_SEGMENT_ID: + return SegmentIdMesg(mesg); + + case FIT_MESG_NUM_SEGMENT_LEADERBOARD_ENTRY: + return SegmentLeaderboardEntryMesg(mesg); + + case FIT_MESG_NUM_SEGMENT_POINT: + return SegmentPointMesg(mesg); + + case FIT_MESG_NUM_SEGMENT_LAP: + return SegmentLapMesg(mesg); + + case FIT_MESG_NUM_SEGMENT_FILE: + return SegmentFileMesg(mesg); + + case FIT_MESG_NUM_WORKOUT: + return WorkoutMesg(mesg); + + case FIT_MESG_NUM_WORKOUT_SESSION: + return WorkoutSessionMesg(mesg); + + case FIT_MESG_NUM_WORKOUT_STEP: + return WorkoutStepMesg(mesg); + + case FIT_MESG_NUM_EXERCISE_TITLE: + return ExerciseTitleMesg(mesg); + + case FIT_MESG_NUM_SCHEDULE: + return ScheduleMesg(mesg); + + case FIT_MESG_NUM_TOTALS: + return TotalsMesg(mesg); + + case FIT_MESG_NUM_WEIGHT_SCALE: + return WeightScaleMesg(mesg); + + case FIT_MESG_NUM_BLOOD_PRESSURE: + return BloodPressureMesg(mesg); + + case FIT_MESG_NUM_MONITORING_INFO: + return MonitoringInfoMesg(mesg); + + case FIT_MESG_NUM_MONITORING: + return MonitoringMesg(mesg); + + case FIT_MESG_NUM_MONITORING_HR_DATA: + return MonitoringHrDataMesg(mesg); + + case FIT_MESG_NUM_SPO2_DATA: + return Spo2DataMesg(mesg); + + case FIT_MESG_NUM_HR: + return HrMesg(mesg); + + case FIT_MESG_NUM_STRESS_LEVEL: + return StressLevelMesg(mesg); + + case FIT_MESG_NUM_MAX_MET_DATA: + return MaxMetDataMesg(mesg); + + case FIT_MESG_NUM_HSA_BODY_BATTERY_DATA: + return HsaBodyBatteryDataMesg(mesg); + + case FIT_MESG_NUM_HSA_EVENT: + return HsaEventMesg(mesg); + + case FIT_MESG_NUM_HSA_ACCELEROMETER_DATA: + return HsaAccelerometerDataMesg(mesg); + + case FIT_MESG_NUM_HSA_GYROSCOPE_DATA: + return HsaGyroscopeDataMesg(mesg); + + case FIT_MESG_NUM_HSA_STEP_DATA: + return HsaStepDataMesg(mesg); + + case FIT_MESG_NUM_HSA_SPO2_DATA: + return HsaSpo2DataMesg(mesg); + + case FIT_MESG_NUM_HSA_STRESS_DATA: + return HsaStressDataMesg(mesg); + + case FIT_MESG_NUM_HSA_RESPIRATION_DATA: + return HsaRespirationDataMesg(mesg); + + case FIT_MESG_NUM_HSA_HEART_RATE_DATA: + return HsaHeartRateDataMesg(mesg); + + case FIT_MESG_NUM_HSA_CONFIGURATION_DATA: + return HsaConfigurationDataMesg(mesg); + + case FIT_MESG_NUM_HSA_WRIST_TEMPERATURE_DATA: + return HsaWristTemperatureDataMesg(mesg); + + case FIT_MESG_NUM_MEMO_GLOB: + return MemoGlobMesg(mesg); + + case FIT_MESG_NUM_SLEEP_LEVEL: + return SleepLevelMesg(mesg); + + case FIT_MESG_NUM_ANT_CHANNEL_ID: + return AntChannelIdMesg(mesg); + + case FIT_MESG_NUM_ANT_RX: + return AntRxMesg(mesg); + + case FIT_MESG_NUM_ANT_TX: + return AntTxMesg(mesg); + + case FIT_MESG_NUM_EXD_SCREEN_CONFIGURATION: + return ExdScreenConfigurationMesg(mesg); + + case FIT_MESG_NUM_EXD_DATA_FIELD_CONFIGURATION: + return ExdDataFieldConfigurationMesg(mesg); + + case FIT_MESG_NUM_EXD_DATA_CONCEPT_CONFIGURATION: + return ExdDataConceptConfigurationMesg(mesg); + + case FIT_MESG_NUM_DIVE_SUMMARY: + return DiveSummaryMesg(mesg); + + case FIT_MESG_NUM_AAD_ACCEL_FEATURES: + return AadAccelFeaturesMesg(mesg); + + case FIT_MESG_NUM_HRV: + return HrvMesg(mesg); + + case FIT_MESG_NUM_BEAT_INTERVALS: + return BeatIntervalsMesg(mesg); + + case FIT_MESG_NUM_HRV_STATUS_SUMMARY: + return HrvStatusSummaryMesg(mesg); + + case FIT_MESG_NUM_HRV_VALUE: + return HrvValueMesg(mesg); + + case FIT_MESG_NUM_RAW_BBI: + return RawBbiMesg(mesg); + + case FIT_MESG_NUM_RESPIRATION_RATE: + return RespirationRateMesg(mesg); + + case FIT_MESG_NUM_CHRONO_SHOT_SESSION: + return ChronoShotSessionMesg(mesg); + + case FIT_MESG_NUM_CHRONO_SHOT_DATA: + return ChronoShotDataMesg(mesg); + + case FIT_MESG_NUM_TANK_UPDATE: + return TankUpdateMesg(mesg); + + case FIT_MESG_NUM_TANK_SUMMARY: + return TankSummaryMesg(mesg); + + case FIT_MESG_NUM_SLEEP_ASSESSMENT: + return SleepAssessmentMesg(mesg); + + case FIT_MESG_NUM_SLEEP_DISRUPTION_SEVERITY_PERIOD: + return SleepDisruptionSeverityPeriodMesg(mesg); + + case FIT_MESG_NUM_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY: + return SleepDisruptionOvernightSeverityMesg(mesg); + + case FIT_MESG_NUM_SKIN_TEMP_OVERNIGHT: + return SkinTempOvernightMesg(mesg); + + case FIT_MESG_NUM_PAD: + return PadMesg(mesg); + + default: + break; + } + return mesg; +} + + +} // namespace fit + diff --git a/fit_factory.hpp b/fit_factory.hpp new file mode 100644 index 0000000..e12241e --- /dev/null +++ b/fit_factory.hpp @@ -0,0 +1,31 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FACTORY_HPP) +#define FIT_FACTORY_HPP + +#include +#include "fit_mesg.hpp" + +namespace fit +{ + +class Factory +{ +public: + static Mesg CreateMesg(Mesg mesg); +private: +}; + +} // namespace fit + +#endif // !defined(FIT_FACTORY_HPP) diff --git a/fit_field.cpp b/fit_field.cpp new file mode 100644 index 0000000..69fcdf7 --- /dev/null +++ b/fit_field.cpp @@ -0,0 +1,169 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include +#include "fit_field.hpp" +#include "fit_mesg.hpp" +#include "fit_unicode.hpp" + +namespace fit +{ + +Field::Field(void) + : FieldBase() + , profile(NULL) + , type(FIT_UINT8_INVALID) + , isFieldExpanded(FIT_FALSE) +{ +} + +Field::Field(const Field &field) + : FieldBase(field) + , profile(field.profile) + , profileIndex(field.profileIndex) + , type(field.type) + , isFieldExpanded(field.isFieldExpanded) +{ +} + +Field::Field(const Profile::MESG_INDEX mesgIndex, const FIT_UINT16 fieldIndex) + : FieldBase() + , profile(&Profile::mesgs[mesgIndex]) + , profileIndex(fieldIndex) + , type(FIT_UINT8_INVALID) + , isFieldExpanded(FIT_FALSE) +{ +} + +Field::Field(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum) + : FieldBase() + , profile(Profile::GetMesg(mesgNum)) + , profileIndex(Profile::GetFieldIndex(mesgNum, fieldNum)) + , type(FIT_UINT8_INVALID) + , isFieldExpanded(FIT_FALSE) +{ +} + +Field::Field(const std::string& mesgName, const std::string& fieldName) + : FieldBase() + , profile(Profile::GetMesg(mesgName)) + , profileIndex(Profile::GetFieldIndex(mesgName, fieldName)) + , type(FIT_UINT8_INVALID) + , isFieldExpanded(FIT_FALSE) +{ +} + +void Field::SetBaseType( FIT_UINT8 type ) +{ + this->type = type; +} + +FIT_BOOL Field::IsValid(void) const +{ + return profileIndex != FIT_UINT16_INVALID; +} + +FIT_BOOL Field::GetIsAccumulated() const +{ + return profile->fields[profileIndex].isAccumulated; +} + +FIT_UINT16 Field::GetIndex(void) const +{ + return profileIndex; +} + +std::string Field::GetName() const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return "unknown"; + return profile->fields[profileIndex].name; +} + +FIT_UINT8 Field::GetNum(void) const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return FIT_FIELD_NUM_INVALID; + return profile->fields[profileIndex].num; +} + +FIT_UINT8 Field::GetType() const +{ + if ( type != FIT_UINT8_INVALID ) + return type; + + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return FIT_UINT8_INVALID; + + return profile->fields[profileIndex].type; +} + +std::string Field::GetUnits() const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return ""; + return profile->fields[profileIndex].units; +} + +FIT_FLOAT64 Field::GetScale() const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return 1; + return profile->fields[profileIndex].scale; +} + +FIT_FLOAT64 Field::GetOffset() const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return 0; + return profile->fields[profileIndex].offset; +} + +FIT_UINT16 Field::GetNumComponents(void) const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return 0; + return profile->fields[profileIndex].numComponents; +} + +FIT_UINT16 Field::GetNumSubFields(void) const +{ + if ((profile == NULL) || (profileIndex >= profile->numFields)) + return 0; + return profile->fields[profileIndex].numSubFields; +} + +FIT_BOOL Field::GetIsExpanded(void) const +{ + return isFieldExpanded; +} + +void Field::SetIsExpanded(FIT_BOOL newValue) +{ + isFieldExpanded = newValue; +} + +const Profile::FIELD_COMPONENT* Field::GetComponent(const FIT_UINT16 component) const +{ + if (component >= GetNumComponents()) + return NULL; + return &profile->fields[profileIndex].components[component]; +} + +const Profile::SUBFIELD* Field::GetSubField(const FIT_UINT16 subFieldIndex) const +{ + if (subFieldIndex >= GetNumSubFields()) + return NULL; + return &profile->fields[profileIndex].subFields[subFieldIndex]; +} +} // namespace fit diff --git a/fit_field.hpp b/fit_field.hpp new file mode 100644 index 0000000..131546b --- /dev/null +++ b/fit_field.hpp @@ -0,0 +1,71 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIELD_HPP) +#define FIELD_HPP + +#include +#include +#include +#include +#include "fit.hpp" +#include "fit_profile.hpp" +#include "fit_field_base.hpp" + +namespace fit +{ + +class Field + : public FieldBase +{ +public: + Field(void); + Field(const Field &field); + Field(const Profile::MESG_INDEX mesgIndex, const FIT_UINT16 fieldIndex); + Field(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum); + Field(const std::string& mesgName, const std::string& fieldName); + + FIT_UINT16 GetIndex(void) const; + FIT_BOOL GetIsExpanded(void) const; + void SetIsExpanded(FIT_BOOL newValue); + + virtual void SetBaseType( FIT_UINT8 type ); + virtual FIT_BOOL IsValid(void) const override; + virtual FIT_BOOL GetIsAccumulated() const override; + virtual std::string GetName(void) const override; + virtual FIT_UINT8 GetNum(void) const override; + virtual FIT_UINT8 GetType(void) const override; + virtual std::string GetUnits(void) const override; + virtual FIT_FLOAT64 GetScale(void) const override; + virtual FIT_FLOAT64 GetOffset(void) const override; + virtual FIT_UINT16 GetNumComponents(void) const override; + virtual FIT_UINT16 GetNumSubFields(void) const override; + virtual const Profile::FIELD_COMPONENT* GetComponent(const FIT_UINT16 component) const override; + virtual const Profile::SUBFIELD* GetSubField(const FIT_UINT16 subFieldIndex) const override; + + // Unhide the overloaded get methods from FieldBase. + using FieldBase::GetName; + using FieldBase::GetType; + using FieldBase::GetUnits; + using FieldBase::GetScale; + using FieldBase::GetOffset; + +private: + const Profile::MESG* profile; + FIT_UINT16 profileIndex; + FIT_UINT8 type; + FIT_BOOL isFieldExpanded; +}; + +} // namespace fit + +#endif // defined(FIELD_HPP) diff --git a/fit_field_base.cpp b/fit_field_base.cpp new file mode 100644 index 0000000..e2816a5 --- /dev/null +++ b/fit_field_base.cpp @@ -0,0 +1,1200 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include +#include "fit_field_base.hpp" +#include "fit_mesg.hpp" +#include "fit_unicode.hpp" + +namespace fit +{ + +FieldBase::FieldBase(void) +{ +} + +FieldBase::FieldBase(const FieldBase &field) +{ + values = field.values; + stringIndexes = field.stringIndexes; +} + +FieldBase::~FieldBase() +{ +} + +std::string FieldBase::GetName(const FIT_UINT16 subFieldIndex) const +{ + if (subFieldIndex >= GetNumSubFields()) + return GetName(); + + auto subfield = GetSubField(subFieldIndex); + return NULL != subfield ? subfield->name : "unknown"; +} + +FIT_UINT8 FieldBase::GetType(const FIT_UINT16 subFieldIndex) const +{ + if (subFieldIndex >= GetNumSubFields()) + return GetType(); + + auto subfield = GetSubField(subFieldIndex); + return NULL != subfield ? subfield->type : FIT_UINT8_INVALID; +} + +std::string FieldBase::GetUnits(const FIT_UINT16 subFieldIndex) const +{ + if (subFieldIndex >= GetNumSubFields()) + return GetUnits(); + + auto subfield = GetSubField(subFieldIndex); + return NULL != subfield ? subfield->units : ""; +} + +FIT_FLOAT64 FieldBase::GetScale(const FIT_UINT16 subFieldIndex) const +{ + if (subFieldIndex >= GetNumSubFields()) + return GetScale(); + + auto subfield = GetSubField(subFieldIndex); + return NULL != subfield ? subfield->scale : 1.0; +} + +FIT_FLOAT64 FieldBase::GetOffset(const FIT_UINT16 subFieldIndex) const +{ + if (subFieldIndex >= GetNumSubFields()) + return GetOffset(); + + auto subfield = GetSubField(subFieldIndex); + return NULL != subfield ? subfield->offset : 0.0; +} + +FIT_BOOL FieldBase::IsSignedInteger(const FIT_UINT16 subFieldIndex) const +{ + switch (GetType(subFieldIndex)) { + case FIT_BASE_TYPE_SINT8: + case FIT_BASE_TYPE_SINT16: + case FIT_BASE_TYPE_SINT32: + return FIT_TRUE; + + default: + return FIT_FALSE; + } +} + +FIT_UINT8 FieldBase::GetSize(void) const +{ + if (!IsValid()) + return 0; + + return (FIT_UINT8)values.size(); +} + +FIT_UINT8 FieldBase::GetNumValues(void) const +{ + if (!IsValid()) + return 0; + + if (GetType() != FIT_BASE_TYPE_STRING) + return (FIT_UINT8)(values.size() / baseTypeSizes[GetType() & FIT_BASE_TYPE_NUM_MASK]); + + return (FIT_UINT8)stringIndexes.size(); +} + +FIT_UINT32 FieldBase::GetBitsValue(const FIT_UINT16 offset, const FIT_UINT8 bits) const +{ + FIT_UINT32 value = 0; + FIT_UINT8 numValueBits = 0; + FIT_UINT8 numDataBitsUsed; + FIT_UINT8 index = 0; + FIT_UINT8 data; + FIT_UINT8 mask; + FIT_UINT16 newOffset = offset; + + if (values.size() == 0) + return FIT_UINT32_INVALID; + + while (numValueBits < bits) + { + if (index >= GetSize()) + return FIT_UINT32_INVALID; + + if (newOffset >= 8) + { + newOffset -= 8; + } + else + { + // Get Nth byte from the jagged array considering elements may be multibyte + data = GetValuesUINT8(index); + // Shift out the bits we do not want to use + data >>= newOffset; + // Record how many bits we are using + numDataBitsUsed = 8 - (FIT_UINT8)newOffset; + // Use every byte after this until we have enough bits + newOffset = 0; + + // If the number of data bits will overflow the number of bits we want in the + // final value, only use as many as will fit + if (numDataBitsUsed > (bits - numValueBits)) + numDataBitsUsed = bits - numValueBits; + + mask = (1 << numDataBitsUsed) - 1; + // OR the data from this byte into our final value, then update number of bits + // in our final value + value |= (FIT_UINT32)(data & mask) << numValueBits; + numValueBits += numDataBitsUsed; + } + index++; + } + + return value; +} + +FIT_SINT32 FieldBase::GetBitsSignedValue(const FIT_UINT16 offset, const FIT_UINT8 bits) const +{ + FIT_UINT32 value; + FIT_SINT32 signedValue; + + value = GetBitsValue(offset, bits); + + if (value == FIT_UINT32_INVALID) + return FIT_SINT32_INVALID; + + signedValue = (1 << (bits - 1)); + + if ((value & signedValue) != 0) // sign bit set + signedValue = -signedValue + (value & (signedValue - 1)); + else + signedValue = value; + + return signedValue; +} + +FIT_BYTE FieldBase::GetValuesBYTE(FIT_UINT8 index) const +{ + /// Returns the Nth byte of the jagged values array + if (index >= GetSize()) + { + return FIT_BYTE_INVALID; + } + + return values[index]; +} + +FIT_UINT8 FieldBase::GetValuesUINT8(FIT_UINT8 index) const +{ + /// Returns the Nth byte of the jagged values array + if (index >= GetSize()) + { + return FIT_UINT8_INVALID; + } + + return values[index]; +} + +FIT_SINT8 FieldBase::GetValuesSINT8(FIT_UINT8 index) const +{ + /// Returns the Nth byte of the jagged values array + if (index >= GetSize()) + { + return FIT_SINT8_INVALID; + } + + return values[index]; +} + +FIT_ENUM FieldBase::GetENUMValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_BYTE FieldBase::GetBYTEValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_SINT8 FieldBase::GetSINT8Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT8 FieldBase::GetUINT8Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT8Z FieldBase::GetUINT8ZValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_SINT16 FieldBase::GetSINT16Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT16 FieldBase::GetUINT16Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT16Z FieldBase::GetUINT16ZValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_SINT32 FieldBase::GetSINT32Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT32 FieldBase::GetUINT32Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT32Z FieldBase::GetUINT32ZValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_SINT64 FieldBase::GetSINT64Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT64 FieldBase::GetUINT64Value(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_UINT64Z FieldBase::GetUINT64ZValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetValue(fieldArrayIndex); +} + +FIT_FLOAT32 FieldBase::GetFLOAT32Value(const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + FIT_FLOAT32 float32Value; + + if (!IsValid()) + return FIT_FLOAT32_INVALID; + + switch (GetType()) { // Note: This checks the type of the MAIN field since data is aligned according to that type + case FIT_BASE_TYPE_BYTE: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_ENUM: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_SINT8: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_UINT8: + case FIT_BASE_TYPE_UINT8Z: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_SINT16: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_UINT16: + case FIT_BASE_TYPE_UINT16Z: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_SINT32: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_UINT32: + case FIT_BASE_TYPE_UINT32Z: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_SINT64: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_UINT64: + case FIT_BASE_TYPE_UINT64Z: + { + float32Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT32); + break; + } + + case FIT_BASE_TYPE_FLOAT32: + { + FIT_SINT32 sint32Value = GetSINT32Value(fieldArrayIndex); + + if (sint32Value == FIT_SINT32_INVALID) + return FIT_FLOAT32_INVALID; + + memcpy(&float32Value, &sint32Value, sizeof(FIT_FLOAT32)); + break; + } + + case FIT_BASE_TYPE_FLOAT64: + return static_cast(GetFLOAT64Value(fieldArrayIndex)); + + default: + return FIT_FLOAT32_INVALID; + } + + if (memcmp(&float32Value, baseTypeInvalids[FIT_BASE_TYPE_FLOAT32 & FIT_BASE_TYPE_NUM_MASK], sizeof(FIT_FLOAT32)) == 0) + { + return float32Value; + } + + return static_cast(static_cast(float32Value) / GetScale(subFieldIndex) - GetOffset(subFieldIndex)); +} + +FIT_FLOAT64 FieldBase::GetFLOAT64Value(const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + FIT_FLOAT64 float64Value; + + if (!IsValid()) + return FIT_FLOAT64_INVALID; + + switch (GetType()) { // Note: This checks the type of the MAIN field since data is aligned according to that type + case FIT_BASE_TYPE_BYTE: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_ENUM: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_SINT8: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_UINT8: + case FIT_BASE_TYPE_UINT8Z: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_SINT16: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_UINT16Z: + case FIT_BASE_TYPE_UINT16: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_SINT32: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_UINT32: + case FIT_BASE_TYPE_UINT32Z: + { + float64Value = + ConvertBaseType(fieldArrayIndex, FIT_BASE_TYPE_FLOAT64); + break; + } + + case FIT_BASE_TYPE_FLOAT32: + { + FIT_FLOAT32 val = GetFLOAT32Value(fieldArrayIndex, subFieldIndex); + + if (FIT_FLOAT32_INVALID == val) + { + return FIT_FLOAT64_INVALID; + } + + return static_cast(val); + } + + case FIT_BASE_TYPE_FLOAT64: + { + FIT_UINT64 uint64Value = GetValue(fieldArrayIndex); + memcpy(&float64Value, &uint64Value, sizeof(FIT_FLOAT64)); + break; + } + + default: + return FIT_FLOAT64_INVALID; + } + + if (memcmp(&float64Value, baseTypeInvalids[FIT_BASE_TYPE_FLOAT64 & FIT_BASE_TYPE_NUM_MASK], sizeof(FIT_FLOAT64)) == 0) + { + return float64Value; + } + + return float64Value / GetScale(subFieldIndex) - GetOffset(subFieldIndex); +} + +FIT_WSTRING FieldBase::GetSTRINGValue(const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + Unicode::UTF8_STRING value; + + if (!IsValid()) + return FIT_WSTRING_INVALID; + + if (GetType() == FIT_BASE_TYPE_STRING) // Note: This checks the type of the MAIN field since data is aligned according to that type + { + FIT_UINT8 numStrings = (FIT_UINT8)stringIndexes.size(); + + if (numStrings == 0) + return FIT_WSTRING_INVALID; + + FIT_UINT8 i = 0; + // Get the start position of the string in the byte array + FIT_UINT8 index = stringIndexes[fieldArrayIndex]; + FIT_UINT8 length; + + // If this is the last string, its length is the size of the array subtracted + // by its start position. + if (fieldArrayIndex + 1 == numStrings) + { + length = (FIT_UINT8)(values.size() - index); + } + // Otherwise it is the distance between its start position and the start + // position of the next string in the byte array. + else + { + length = stringIndexes[fieldArrayIndex + 1] - index; + } + + while ((i < length) && (values[index + i] != 0)) + { + value += static_cast(values[index + i]); + i++; + } + } + else + { + FIT_FLOAT64 floatValue = GetFLOAT64Value(fieldArrayIndex, subFieldIndex); + + if (floatValue != FIT_FLOAT64_INVALID) + { + Unicode::UTF8_OSSTREAM valueStream; + valueStream.setf(std::ios_base::fixed); + valueStream.precision(9); + valueStream << floatValue; + value = valueStream.str(); + + if ((value.find('.') != Unicode::UTF8_STRING::npos) && (value[value.length() - 1] == '0')) + { + Unicode::UTF8_STRING::size_type lastZeroIndex = value.length() - 1; + + while (value[lastZeroIndex - 1] == '0') + lastZeroIndex--; + + if (value[lastZeroIndex - 1] == '.') + value.erase(lastZeroIndex - 1); + else + value.erase(lastZeroIndex); + } + } + else + { + value = ""; + } + } + + return Unicode::Encode_UTF8ToBase(value); +} + +FIT_UINT16 FieldBase::GetSubField(const std::string& subFieldName) const +{ + for (FIT_UINT16 i = 0; i < this->GetNumSubFields(); i++) { + if ( this->GetSubField(i)->name.compare(subFieldName) == 0) + return i; + } + + return FIT_SUBFIELD_INDEX_MAIN_FIELD; +} + +FIT_FLOAT64 FieldBase::GetRawValue() const +{ + return GetRawValueInternal(0); +} + +FIT_FLOAT64 FieldBase::GetRawValue(const FIT_UINT8 fieldArrayIndex) const +{ + return GetRawValueInternal(fieldArrayIndex); +} + +FIT_BOOL FieldBase::GetMemoryValue( const FIT_UINT8 fieldArrayIndex, FIT_UINT8* buffer, const FIT_UINT8 bufferSize ) const +{ + FIT_UINT8 baseTypeSize = baseTypeSizes[GetType() & FIT_BASE_TYPE_NUM_MASK]; + FIT_UINT8 offsetIndex = baseTypeSize * fieldArrayIndex; + if ( bufferSize < baseTypeSize ) + { + // Buffer is not large enough + return FIT_FALSE; + } + + if ( static_cast(offsetIndex + baseTypeSize) > values.size() ) + { + // Values do not contain valid Data + return FIT_FALSE; + } + + for ( FIT_UINT8 i = 0; i < baseTypeSize; i++ ) + { + buffer[i] = values[offsetIndex + i]; + } + + return FIT_TRUE; +} + +FIT_FLOAT64 FieldBase::GetRawValueInternal(const FIT_UINT8 fieldArrayIndex) const +{ + FIT_FLOAT64 float64Value; + + if (!IsValid()) + return FIT_FLOAT64_INVALID; + + switch (GetType()) { // Note: This checks the type of the MAIN field since data is aligned according to that type + case FIT_BASE_TYPE_BYTE: + { + FIT_BYTE byteValue = GetBYTEValue(fieldArrayIndex); + + if (byteValue == FIT_BYTE_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = byteValue; + break; + } + + case FIT_BASE_TYPE_ENUM: + { + FIT_ENUM enumValue = GetENUMValue(fieldArrayIndex); + + if (enumValue == FIT_ENUM_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = enumValue; + break; + } + + case FIT_BASE_TYPE_SINT8: + { + FIT_SINT8 sint8Value = GetSINT8Value(fieldArrayIndex); + + if (sint8Value == FIT_SINT8_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = sint8Value; + break; + } + + case FIT_BASE_TYPE_UINT8: + { + FIT_UINT8 uint8Value = GetUINT8Value(fieldArrayIndex); + + if (uint8Value == FIT_UINT8_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = uint8Value; + break; + } + + case FIT_BASE_TYPE_UINT8Z: + { + FIT_UINT8Z uint8zValue = GetUINT8ZValue(fieldArrayIndex); + + if (uint8zValue == FIT_UINT8Z_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = uint8zValue; + break; + } + + case FIT_BASE_TYPE_SINT16: + { + FIT_SINT16 sint16Value = GetSINT16Value(fieldArrayIndex); + + if (sint16Value == FIT_SINT16_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = sint16Value; + break; + } + + case FIT_BASE_TYPE_UINT16: + { + FIT_UINT16 uint16Value = GetUINT16Value(fieldArrayIndex); + + if (uint16Value == FIT_UINT16_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = uint16Value; + break; + } + + case FIT_BASE_TYPE_UINT16Z: + { + FIT_UINT16Z uint16zValue = GetUINT16ZValue(fieldArrayIndex); + + if (uint16zValue == FIT_UINT16Z_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = uint16zValue; + break; + } + + case FIT_BASE_TYPE_SINT32: + { + FIT_SINT32 sint32Value = GetSINT32Value(fieldArrayIndex); + + if (sint32Value == FIT_SINT32_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = sint32Value; + break; + } + + case FIT_BASE_TYPE_UINT32: + { + FIT_UINT32 uint32Value = GetUINT32Value(fieldArrayIndex); + + if (uint32Value == FIT_UINT32_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = uint32Value; + break; + } + + case FIT_BASE_TYPE_UINT32Z: + { + FIT_UINT32Z uint32zValue = GetUINT32ZValue(fieldArrayIndex); + + if (uint32zValue == FIT_UINT32Z_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = uint32zValue; + break; + } + + case FIT_BASE_TYPE_FLOAT32: + { + FIT_FLOAT32 float32Value = GetFLOAT32Value(fieldArrayIndex); + + if (float32Value == FIT_FLOAT32_INVALID) + return FIT_FLOAT64_INVALID; + + float64Value = float32Value; + break; + } + + case FIT_BASE_TYPE_FLOAT64: + { + unsigned long long uint64Value = 0; + + if (fieldArrayIndex >= (FIT_UINT8)values.size()) + return FIT_FLOAT64_INVALID; + + for (size_t i = 0; i < sizeof(FIT_UINT64); i++) + { + uint64Value |= ( values[(fieldArrayIndex * sizeof(FIT_UINT64)) + i] << (i * 8) ); + } + + memcpy(&float64Value, &uint64Value, sizeof(FIT_FLOAT64)); + break; + } + + default: + return FIT_FLOAT64_INVALID; + } + + return float64Value; +} + +void FieldBase::AddValue(const FIT_FLOAT64 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + SetFLOAT64Value( value, fieldArrayIndex, subFieldIndex ); +} + +// rawValue is already the correct quantity (scale/offsets applied) but possibly not the +// correct underlying type +void FieldBase::AddRawValue(const FIT_FLOAT64 rawValue, const FIT_UINT8 fieldArrayIndex) +{ + FIT_FLOAT64 roundedValue = FieldBase::Round(rawValue); + switch ( GetType() ) + { + case FIT_BASE_TYPE_BYTE: + case FIT_BASE_TYPE_ENUM: + case FIT_BASE_TYPE_SINT8: + case FIT_BASE_TYPE_UINT8: + case FIT_BASE_TYPE_UINT8Z: + SetUINT8Value((FIT_UINT8)roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_SINT16: + case FIT_BASE_TYPE_UINT16: + case FIT_BASE_TYPE_UINT16Z: + SetUINT16Value((FIT_UINT16)roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_SINT32: + case FIT_BASE_TYPE_UINT32: + case FIT_BASE_TYPE_UINT32Z: + SetUINT32Value((FIT_UINT32)roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_FLOAT32: + { + FIT_FLOAT32 float32Value = (FIT_FLOAT32)roundedValue; + FIT_UINT32 uint32Value; + memcpy(&uint32Value, &float32Value, sizeof(FIT_FLOAT32)); + SetUINT32Value(uint32Value, fieldArrayIndex); + break; + } + + case FIT_BASE_TYPE_FLOAT64: + if ((FIT_UINT8)values.size() < ((fieldArrayIndex + 1) * sizeof(FIT_FLOAT64))) + { + values.resize((fieldArrayIndex + 1) * 8); + } + + for (size_t i = 0; i < sizeof(FIT_FLOAT64); i++) + { + values[(fieldArrayIndex * sizeof(FIT_FLOAT64) + i)] = (*(((FIT_BYTE *)&rawValue) + i)); + } + break; + + default: + break; + } +} + + +void FieldBase::SetENUMValue(const FIT_ENUM value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT8Value(value, fieldArrayIndex); +} + +void FieldBase::SetBYTEValue(const FIT_BYTE value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT8Value(value, fieldArrayIndex); +} + +void FieldBase::SetSINT8Value(const FIT_SINT8 value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT8Value(value, fieldArrayIndex); +} + +void FieldBase::SetUINT8Value(const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex) +{ + if ((FIT_UINT8)values.size() < (fieldArrayIndex + 1)) + { + values.resize(fieldArrayIndex + 1); + } + + values[fieldArrayIndex] = (FIT_BYTE)value; +} + +void FieldBase::SetUINT8ZValue(const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT8Value(value, fieldArrayIndex); +} + +void FieldBase::SetSINT16Value(const FIT_SINT16 value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT16Value(value, fieldArrayIndex); +} + +void FieldBase::SetUINT16Value(const FIT_UINT16 value, const FIT_UINT8 fieldArrayIndex) +{ + if ((FIT_UINT8)values.size() < ((fieldArrayIndex + 1) * sizeof(FIT_UINT16))) + { + values.resize((fieldArrayIndex + 1) * sizeof(FIT_UINT16)); + } + + for (size_t i = 0; i < sizeof(FIT_UINT16); i++) + { + values[(fieldArrayIndex * sizeof(FIT_UINT16)) + i] = ((FIT_BYTE)(value >> (8 * i))); + } +} + +void FieldBase::SetUINT16ZValue(const FIT_UINT16Z value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT16Value(value, fieldArrayIndex); +} + +void FieldBase::SetSINT32Value(const FIT_SINT32 value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT32Value(value, fieldArrayIndex); +} + +void FieldBase::SetUINT32Value(const FIT_UINT32 value, const FIT_UINT8 fieldArrayIndex) +{ + if ((FIT_UINT8)values.size() < ((fieldArrayIndex + 1) * sizeof(FIT_UINT32))) + { + values.resize((fieldArrayIndex + 1) * sizeof(FIT_UINT32)); + } + + for (size_t i = 0; i < sizeof(FIT_UINT32); i++) + { + values[(fieldArrayIndex * sizeof(FIT_UINT32)) + i] = ((FIT_BYTE)(value >> (8 * i))); + } +} + +void FieldBase::SetUINT32ZValue(const FIT_UINT32Z value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT32Value(value, fieldArrayIndex); +} + +void FieldBase::SetSINT64Value(const FIT_SINT64 value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT64Value(value, fieldArrayIndex); +} + +void FieldBase::SetUINT64Value(const FIT_UINT64 value, const FIT_UINT8 fieldArrayIndex) +{ + if ((FIT_UINT8)values.size() < ((fieldArrayIndex + 1) * sizeof(FIT_UINT64))) + { + values.resize((fieldArrayIndex + 1) * sizeof(FIT_UINT64)); + } + + for (size_t i = 0; i < sizeof(FIT_UINT64); i++) + { + values[(fieldArrayIndex * sizeof(FIT_UINT64)) + i] = ((FIT_BYTE)(value >> (8 * i))); + } +} + +void FieldBase::SetUINT64ZValue(const FIT_UINT64Z value, const FIT_UINT8 fieldArrayIndex) +{ + SetUINT64Value(value, fieldArrayIndex); +} + +void FieldBase::SetFLOAT32Value(const FIT_FLOAT32 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + SetFLOAT64Value(value, fieldArrayIndex, subFieldIndex); +} + +void FieldBase::SetFLOAT64Value(const FIT_FLOAT64 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!IsValid()) + return; + + FIT_FLOAT64 recalculatedValue = (value + GetOffset(subFieldIndex)) * GetScale(subFieldIndex); + // Make sure floating point representations trunc to the expected integer + FIT_FLOAT64 roundedValue = (recalculatedValue >= 0.0) ? (recalculatedValue + 0.5) : (recalculatedValue - 0.5); + + switch (GetType()) { // Note: This checks the type of the MAIN field since data is aligned according to that type + case FIT_BASE_TYPE_BYTE: + case FIT_BASE_TYPE_ENUM: + case FIT_BASE_TYPE_SINT8: + case FIT_BASE_TYPE_UINT8: + case FIT_BASE_TYPE_UINT8Z: + SetUINT8Value((FIT_UINT8) roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_SINT16: + case FIT_BASE_TYPE_UINT16: + case FIT_BASE_TYPE_UINT16Z: + SetUINT16Value((FIT_UINT16) roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_SINT32: + case FIT_BASE_TYPE_UINT32: + case FIT_BASE_TYPE_UINT32Z: + SetUINT32Value((FIT_UINT32) roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_SINT64: + case FIT_BASE_TYPE_UINT64: + case FIT_BASE_TYPE_UINT64Z: + SetUINT64Value((FIT_UINT64) roundedValue, fieldArrayIndex); + break; + + case FIT_BASE_TYPE_FLOAT32: + { + FIT_FLOAT32 float32Value = (FIT_FLOAT32)recalculatedValue; + FIT_UINT32 uint32Value; + memcpy(&uint32Value, &float32Value, sizeof(FIT_FLOAT32)); + SetUINT32Value(uint32Value, fieldArrayIndex); + break; + } + + case FIT_BASE_TYPE_FLOAT64: + if ((FIT_UINT8)values.size() < ((fieldArrayIndex + 1) * sizeof(FIT_FLOAT64))) + { + values.resize((fieldArrayIndex + 1) * sizeof(FIT_FLOAT64)); + } + + for (size_t i = 0; i < sizeof(FIT_FLOAT64); i++) + { + values[(fieldArrayIndex * sizeof(FIT_FLOAT64)) + i] = *(((FIT_BYTE *)&recalculatedValue) + i); + } + + break; + + default: + break; + } +} + +void FieldBase::SetSTRINGValue(const FIT_WSTRING& value, const FIT_UINT8 fieldArrayIndex) +{ + if (!IsValid()) + return; + + Unicode::UTF8_STRING stringValue = Unicode::Encode_BaseToUTF8(value); + FIT_UINT8 stringLength = (FIT_UINT8)stringValue.length(); + FIT_UINT8 idx = 0; + FIT_UINT8 nextIdx = 0; + FIT_UINT8 numStrings = (FIT_UINT8)stringIndexes.size(); + FIT_UINT8 dif = 0; + + if ( fieldArrayIndex < numStrings ) + { + idx = stringIndexes[fieldArrayIndex]; + if (fieldArrayIndex + 1 < numStrings) + { + nextIdx = stringIndexes[fieldArrayIndex + 1]; + dif = (FIT_UINT8)( (value.length() + 1) - (nextIdx - idx) ); + values.erase(values.begin() + idx, values.begin() + nextIdx); + } + else + { + values.erase(values.begin() + idx, values.end()); + } + + for (auto i = 0; i < stringLength + 1; i++) + values.insert(values.begin() + idx + i, 0); + } + else + { + idx = (FIT_UINT8)values.size(); + numStrings++; + stringIndexes.push_back(idx); + for (auto j = 0; j < stringLength + 1; j++) + { + values.push_back(0); + } + } + + int i; + for (i = 0; i < (int)stringValue.length(); i++) + { + values[idx + i] = static_cast(stringValue[i]); + } + + values[idx + i] = 0; // null terminate +} + +FIT_BOOL FieldBase::Read(const void *data, const FIT_UINT8 size) +{ + FIT_UINT8 bytesLeft = size; + FIT_UINT8 typeSize = baseTypeSizes[GetType() & FIT_BASE_TYPE_NUM_MASK]; + FIT_BYTE *byteData = (FIT_BYTE *) data; + + values.clear(); + + switch (GetType()) + { + case FIT_BASE_TYPE_STRING: + { + FIT_BOOL hasData = FIT_FALSE; + FIT_UINT8 stringPos = 0; + FIT_UINT8 index = 0; + + // Check if the string is empty + while (index < bytesLeft) + { + if (byteData[index] != 0) + { + hasData = FIT_TRUE; + break; + } + index++; + } + + if (!hasData) + break; + + stringIndexes.push_back(stringPos); + + while (bytesLeft-- > 0) + { + FIT_BYTE byte = *byteData++; + values.push_back(byte); + stringPos++; + + if ( ( byte == 0 ) && ( stringPos + 1 < size ) ) + { + stringIndexes.push_back(stringPos); + } + } + + // Null terminate if not already null terminated + if ( values.back() != 0 ) + { + values.push_back(0); + } + } + break; + + default: + { + int bytes = bytesLeft; + FIT_BYTE *point = byteData; + + while (bytes > 0) + { + if (memcmp(point, baseTypeInvalids[GetType() & FIT_BASE_TYPE_NUM_MASK], typeSize) != 0) + { + values.insert(values.end(), byteData, byteData + bytesLeft); + break; + } + point += typeSize; + bytes -= typeSize; + } + } + break; + } + + return FIT_TRUE; +} + +FIT_UINT8 FieldBase::Write(std::ostream &file) const +{ + file.write((const char*)values.data(), values.size()); + + return GetSize(); +} + +FIT_BOOL FieldBase::IsValueValid( const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subfieldIndex ) const +{ + FIT_BOOL isValid = FIT_FALSE; + + FIT_UINT8 type = GetType( subfieldIndex ); + + if ( FIT_UINT8_INVALID == type ) + { + // Invalid Subfield Index use the default type + type = GetType(); + } + + if ( FIT_BASE_TYPE_STRING == type ) + { + FIT_WSTRING strVal = GetSTRINGValue( fieldArrayIndex ); + + isValid = ( strVal != FIT_WSTRING_INVALID ); + } + else + { + FIT_UINT8 baseTypeSize = baseTypeSizes[type & FIT_BASE_TYPE_NUM_MASK]; + const FIT_UINT8* invalid = baseTypeInvalids[type & FIT_BASE_TYPE_NUM_MASK]; + FIT_UINT8* data = new FIT_UINT8[baseTypeSize]; + + FIT_BOOL readSuccess = GetMemoryValue( fieldArrayIndex, data, baseTypeSize ); + + //! TODO Handle Strings + if ( readSuccess ) + { + isValid = ( memcmp( invalid, data, baseTypeSize ) != 0 ); + } + delete[] data; + } + + return isValid; +} + +FIT_FLOAT64 FieldBase::Round(FIT_FLOAT64 value) +{ + return (value > 0.0) ? floor(value + 0.5) : ceil(value - 0.5); +} + +template +T FieldBase::GetValue(const FIT_UINT8 fieldArrayIndex) const +{ + FIT_UINT8 size = baseTypeSizes[GetType() & FIT_BASE_TYPE_NUM_MASK]; + if (fieldArrayIndex >= (FIT_UINT8)values.size()) + { + return *reinterpret_cast(baseTypeInvalids[GetType() & FIT_BASE_TYPE_NUM_MASK]); + } + + T rv = 0; + + for (int i = 0; i < size; i++) + { + rv |= static_cast(values[(fieldArrayIndex * size) + i]) << (i * 8); + } + + return rv; +} + + +template +TTo FieldBase::ConvertBaseType(const FIT_UINT8 fieldArrayIndex, const FIT_UINT8 toBaseType) const +{ + FIT_CONST_UINT8_PTR invalid = baseTypeInvalids[GetType() & FIT_BASE_TYPE_NUM_MASK]; + TFrom value = GetValue(fieldArrayIndex); + + if (memcmp(&value, invalid, sizeof(TFrom)) == 0) + return *reinterpret_cast(baseTypeInvalids[toBaseType & FIT_BASE_TYPE_NUM_MASK]); + + return static_cast(value); +} +} // namespace fit diff --git a/fit_field_base.hpp b/fit_field_base.hpp new file mode 100644 index 0000000..461c03f --- /dev/null +++ b/fit_field_base.hpp @@ -0,0 +1,126 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIELD_BASE_HPP) +#define FIELD_BASE_HPP + +#include +#include +#include +#include +#include "fit.hpp" +#include "fit_profile.hpp" + +namespace fit +{ + +class FieldBase +{ +public: + FieldBase(void); + FieldBase(const FieldBase& other); + virtual ~FieldBase(); + + std::string GetName(const FIT_UINT16 subFieldIndex) const; + FIT_UINT8 GetType(const FIT_UINT16 subFieldIndex) const; + std::string GetUnits(const FIT_UINT16 subFieldIndex) const; + FIT_FLOAT64 GetScale(const FIT_UINT16 subFieldIndex) const; + FIT_FLOAT64 GetOffset(const FIT_UINT16 subFieldIndex) const; + + virtual FIT_BOOL GetIsAccumulated() const = 0; + virtual FIT_BOOL IsValid(void) const = 0; + virtual FIT_UINT8 GetNum(void) const = 0; + virtual std::string GetName() const = 0; + virtual FIT_UINT8 GetType() const = 0; + virtual std::string GetUnits() const = 0; + virtual FIT_FLOAT64 GetScale() const = 0; + virtual FIT_FLOAT64 GetOffset() const = 0; + virtual const Profile::SUBFIELD* GetSubField(const FIT_UINT16 subFieldIndex) const = 0; + virtual FIT_UINT16 GetNumSubFields(void) const = 0; + virtual const Profile::FIELD_COMPONENT* GetComponent(const FIT_UINT16 component) const = 0; + virtual FIT_UINT16 GetNumComponents(void) const = 0; + + FIT_BOOL IsSignedInteger(const FIT_UINT16 subFieldIndex = 0) const; + FIT_UINT8 GetSize(void) const; + FIT_UINT8 GetNumValues(void) const; + + FIT_UINT32 GetBitsValue(const FIT_UINT16 offset, const FIT_UINT8 bits) const; + FIT_SINT32 GetBitsSignedValue(const FIT_UINT16 offset, const FIT_UINT8 bits) const; + FIT_BYTE GetValuesBYTE(const FIT_UINT8 index) const; + FIT_SINT8 GetValuesSINT8(const FIT_UINT8 index) const; + FIT_UINT8 GetValuesUINT8(const FIT_UINT8 index) const; + FIT_FLOAT32 GetFLOAT32Value(const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD) const; + FIT_FLOAT64 GetFLOAT64Value(const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD) const; + FIT_WSTRING GetSTRINGValue(const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD) const; + FIT_FLOAT64 GetRawValue() const; + FIT_FLOAT64 GetRawValue(const FIT_UINT8 fieldArrayIndex) const; + FIT_ENUM GetENUMValue(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_BYTE GetBYTEValue(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_SINT8 GetSINT8Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT8 GetUINT8Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT8Z GetUINT8ZValue(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_SINT16 GetSINT16Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT16 GetUINT16Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT16Z GetUINT16ZValue(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_SINT32 GetSINT32Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT32 GetUINT32Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT32Z GetUINT32ZValue(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_SINT64 GetSINT64Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT64 GetUINT64Value(const FIT_UINT8 fieldArrayIndex = 0) const; + FIT_UINT64Z GetUINT64ZValue(const FIT_UINT8 fieldArrayIndex = 0) const; + + void AddRawValue(const FIT_FLOAT64 rawValue, const FIT_UINT8 fieldArrayIndex = 0); + void SetENUMValue(const FIT_ENUM value, const FIT_UINT8 fieldArrayIndex = 0); + void SetBYTEValue(const FIT_BYTE value, const FIT_UINT8 fieldArrayIndex = 0); + void SetSINT8Value(const FIT_SINT8 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT8Value(const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT8ZValue(const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetSINT16Value(const FIT_SINT16 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT16Value(const FIT_UINT16 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT16ZValue(const FIT_UINT16Z value, const FIT_UINT8 fieldArrayIndex = 0); + void SetSINT32Value(const FIT_SINT32 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT32Value(const FIT_UINT32 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT32ZValue(const FIT_UINT32Z value, const FIT_UINT8 fieldArrayIndex = 0); + void SetSINT64Value(const FIT_SINT64 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT64Value(const FIT_UINT64 value, const FIT_UINT8 fieldArrayIndex = 0); + void SetUINT64ZValue(const FIT_UINT64Z value, const FIT_UINT8 fieldArrayIndex = 0); + void SetFLOAT32Value(const FIT_FLOAT32 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD); + void SetFLOAT64Value(const FIT_FLOAT64 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD); + void SetSTRINGValue(const FIT_WSTRING& value, const FIT_UINT8 fieldArrayIndex = 0); + void AddValue(const FIT_FLOAT64 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD); + + FIT_BOOL Read(const void *data, const FIT_UINT8 size); + FIT_UINT8 Write(std::ostream &file) const; + FIT_BOOL IsValueValid(const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subfieldIndex = FIT_SUBFIELD_INDEX_MAIN_FIELD) const; + +protected: + FIT_UINT16 GetSubField(const std::string& subFieldName) const; + +private: + template + T GetValue(const FIT_UINT8 fieldArrayIndex) const; + + template + TTo ConvertBaseType(const FIT_UINT8 fieldArrayIndex, const FIT_UINT8 toBaseType) const; + + FIT_BOOL GetMemoryValue(const FIT_UINT8 fieldArrayIndex, FIT_UINT8 * buffer, const FIT_UINT8 bufferSize) const; + + FIT_FLOAT64 GetRawValueInternal(const FIT_UINT8 fieldArrayIndex = 0) const; + static FIT_FLOAT64 Round(FIT_FLOAT64 value); + + std::vector values; + std::vector stringIndexes; +}; + +} // namespace fit + +#endif // defined(FIELD_BASE_HPP) diff --git a/fit_field_capabilities_mesg.hpp b/fit_field_capabilities_mesg.hpp new file mode 100644 index 0000000..3b464c7 --- /dev/null +++ b/fit_field_capabilities_mesg.hpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FIELD_CAPABILITIES_MESG_HPP) +#define FIT_FIELD_CAPABILITIES_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class FieldCapabilitiesMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 File = 0; + static const FIT_UINT8 MesgNum = 1; + static const FIT_UINT8 FieldNum = 2; + static const FIT_UINT8 Count = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + FieldCapabilitiesMesg(void) : Mesg(Profile::MESG_FIELD_CAPABILITIES) + { + } + + FieldCapabilitiesMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of file field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFileValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns file field + /////////////////////////////////////////////////////////////////////// + FIT_FILE GetFile(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set file field + /////////////////////////////////////////////////////////////////////// + void SetFile(FIT_FILE file) + { + SetFieldENUMValue(0, file, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgNumValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_num field + /////////////////////////////////////////////////////////////////////// + FIT_MESG_NUM GetMesgNum(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_num field + /////////////////////////////////////////////////////////////////////// + void SetMesgNum(FIT_MESG_NUM mesgNum) + { + SetFieldUINT16Value(1, mesgNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldNumValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_num field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFieldNum(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_num field + /////////////////////////////////////////////////////////////////////// + void SetFieldNum(FIT_UINT8 fieldNum) + { + SetFieldUINT8Value(2, fieldNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCountValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCount(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set count field + /////////////////////////////////////////////////////////////////////// + void SetCount(FIT_UINT16 count) + { + SetFieldUINT16Value(3, count, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_FIELD_CAPABILITIES_MESG_HPP) diff --git a/fit_field_capabilities_mesg_listener.hpp b/fit_field_capabilities_mesg_listener.hpp new file mode 100644 index 0000000..5d52e19 --- /dev/null +++ b/fit_field_capabilities_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FIELD_CAPABILITIES_MESG_LISTENER_HPP) +#define FIT_FIELD_CAPABILITIES_MESG_LISTENER_HPP + +#include "fit_field_capabilities_mesg.hpp" + +namespace fit +{ + +class FieldCapabilitiesMesgListener +{ +public: + virtual ~FieldCapabilitiesMesgListener() {} + virtual void OnMesg(FieldCapabilitiesMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_FIELD_CAPABILITIES_MESG_LISTENER_HPP) diff --git a/fit_field_definition.cpp b/fit_field_definition.cpp new file mode 100644 index 0000000..a0845c3 --- /dev/null +++ b/fit_field_definition.cpp @@ -0,0 +1,103 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include "fit_field_definition.hpp" + +namespace fit +{ + +FieldDefinition::FieldDefinition() + : num(FIT_FIELD_NUM_INVALID), size(0), type(FIT_UINT8_INVALID) +{ +} + +FieldDefinition::FieldDefinition(const Field& field) + : num(field.GetNum()), size(field.GetSize()), type(field.GetType()) +{ +} + +FieldDefinition::FieldDefinition(const Field* field) +{ + if (field != FIT_NULL) + { + num = field->GetNum(); + size = field->GetSize(); + type = field->GetType(); + } + else + { + num = FIT_FIELD_NUM_INVALID; + size = 0; + type = FIT_UINT8_INVALID; + } +} + +FIT_UINT8 FieldDefinition::GetNum() const +{ + return num; +} + +FIT_UINT8 FieldDefinition::GetSize() const +{ + return size; +} + +FIT_UINT8 FieldDefinition::GetType() const +{ + return type; +} + +void FieldDefinition::SetNum(const FIT_UINT8 newNum) +{ + num = newNum; +} + +void FieldDefinition::SetSize(const FIT_UINT8 newSize) +{ + size = newSize; +} + +void FieldDefinition::SetType(const FIT_UINT8 newType) +{ + type = newType; +} + +FIT_BOOL FieldDefinition::operator==(const FieldDefinition& field) const +{ + if (num != field.num) + return FIT_FALSE; + + if (size != field.size) + return FIT_FALSE; + + if (type != field.type) + return FIT_FALSE; + + return FIT_TRUE; +} + +FIT_BOOL FieldDefinition::operator!=(const FieldDefinition& field) const +{ + return !(*this==field); +} + +FIT_UINT8 FieldDefinition::Write(std::ostream &file) const +{ + file.put(num); + file.put(size); + file.put(type); + + return 3; +} + +} // namespace fit diff --git a/fit_field_definition.hpp b/fit_field_definition.hpp new file mode 100644 index 0000000..929aac3 --- /dev/null +++ b/fit_field_definition.hpp @@ -0,0 +1,47 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FIELD_DEFINITION_HPP) +#define FIT_FIELD_DEFINITION_HPP + +#include +#include "fit.hpp" +#include "fit_field.hpp" + +namespace fit +{ + +class FieldDefinition +{ +public: + FieldDefinition(); + FieldDefinition(const Field& field); + FieldDefinition(const Field* field); + FIT_UINT8 GetNum() const; + FIT_UINT8 GetSize() const; + FIT_UINT8 GetType() const; + void SetNum(const FIT_UINT8 newNum); + void SetSize(const FIT_UINT8 newSize); + void SetType(const FIT_UINT8 newType); + FIT_BOOL operator==(const FieldDefinition& field) const; + FIT_BOOL operator!=(const FieldDefinition& field) const; + FIT_UINT8 Write(std::ostream &file) const; + +private: + FIT_UINT8 num; + FIT_UINT8 size; + FIT_UINT8 type; +}; + +} // namespace fit + +#endif // defined(FIT_FIELD_DEFINITION_HPP) diff --git a/fit_field_description_mesg.hpp b/fit_field_description_mesg.hpp new file mode 100644 index 0000000..f3b3495 --- /dev/null +++ b/fit_field_description_mesg.hpp @@ -0,0 +1,506 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FIELD_DESCRIPTION_MESG_HPP) +#define FIT_FIELD_DESCRIPTION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class FieldDescriptionMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 DeveloperDataIndex = 0; + static const FIT_UINT8 FieldDefinitionNumber = 1; + static const FIT_UINT8 FitBaseTypeId = 2; + static const FIT_UINT8 FieldName = 3; + static const FIT_UINT8 Array = 4; + static const FIT_UINT8 Components = 5; + static const FIT_UINT8 Scale = 6; + static const FIT_UINT8 Offset = 7; + static const FIT_UINT8 Units = 8; + static const FIT_UINT8 Bits = 9; + static const FIT_UINT8 Accumulate = 10; + static const FIT_UINT8 FitBaseUnitId = 13; + static const FIT_UINT8 NativeMesgNum = 14; + static const FIT_UINT8 NativeFieldNum = 15; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + FieldDescriptionMesg(void) : Mesg(Profile::MESG_FIELD_DESCRIPTION) + { + } + + FieldDescriptionMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of developer_data_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeveloperDataIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns developer_data_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDeveloperDataIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set developer_data_index field + /////////////////////////////////////////////////////////////////////// + void SetDeveloperDataIndex(FIT_UINT8 developerDataIndex) + { + SetFieldUINT8Value(0, developerDataIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_definition_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldDefinitionNumberValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_definition_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFieldDefinitionNumber(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_definition_number field + /////////////////////////////////////////////////////////////////////// + void SetFieldDefinitionNumber(FIT_UINT8 fieldDefinitionNumber) + { + SetFieldUINT8Value(1, fieldDefinitionNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fit_base_type_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFitBaseTypeIdValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fit_base_type_id field + /////////////////////////////////////////////////////////////////////// + FIT_FIT_BASE_TYPE GetFitBaseTypeId(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fit_base_type_id field + /////////////////////////////////////////////////////////////////////// + void SetFitBaseTypeId(FIT_FIT_BASE_TYPE fitBaseTypeId) + { + SetFieldUINT8Value(2, fitBaseTypeId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of field_name + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumFieldName(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldNameValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetFieldName(FIT_UINT8 index) const + { + return GetFieldSTRINGValue(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_name field + /////////////////////////////////////////////////////////////////////// + void SetFieldName(FIT_UINT8 index, FIT_WSTRING fieldName) + { + SetFieldSTRINGValue(3, fieldName, index); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of array field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsArrayValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns array field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetArray(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set array field + /////////////////////////////////////////////////////////////////////// + void SetArray(FIT_UINT8 array) + { + SetFieldUINT8Value(4, array, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of components field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsComponentsValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns components field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetComponents(void) const + { + return GetFieldSTRINGValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set components field + /////////////////////////////////////////////////////////////////////// + void SetComponents(FIT_WSTRING components) + { + SetFieldSTRINGValue(5, components, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of scale field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScaleValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns scale field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetScale(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set scale field + /////////////////////////////////////////////////////////////////////// + void SetScale(FIT_UINT8 scale) + { + SetFieldUINT8Value(6, scale, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOffsetValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns offset field + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetOffset(void) const + { + return GetFieldSINT8Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set offset field + /////////////////////////////////////////////////////////////////////// + void SetOffset(FIT_SINT8 offset) + { + SetFieldSINT8Value(7, offset, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of units + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumUnits(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of units field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUnitsValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns units field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetUnits(FIT_UINT8 index) const + { + return GetFieldSTRINGValue(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set units field + /////////////////////////////////////////////////////////////////////// + void SetUnits(FIT_UINT8 index, FIT_WSTRING units) + { + SetFieldSTRINGValue(8, units, index); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bits field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBitsValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bits field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetBits(void) const + { + return GetFieldSTRINGValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bits field + /////////////////////////////////////////////////////////////////////// + void SetBits(FIT_WSTRING bits) + { + SetFieldSTRINGValue(9, bits, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accumulate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccumulateValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accumulate field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetAccumulate(void) const + { + return GetFieldSTRINGValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accumulate field + /////////////////////////////////////////////////////////////////////// + void SetAccumulate(FIT_WSTRING accumulate) + { + SetFieldSTRINGValue(10, accumulate, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fit_base_unit_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFitBaseUnitIdValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fit_base_unit_id field + /////////////////////////////////////////////////////////////////////// + FIT_FIT_BASE_UNIT GetFitBaseUnitId(void) const + { + return GetFieldUINT16Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fit_base_unit_id field + /////////////////////////////////////////////////////////////////////// + void SetFitBaseUnitId(FIT_FIT_BASE_UNIT fitBaseUnitId) + { + SetFieldUINT16Value(13, fitBaseUnitId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of native_mesg_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNativeMesgNumValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns native_mesg_num field + /////////////////////////////////////////////////////////////////////// + FIT_MESG_NUM GetNativeMesgNum(void) const + { + return GetFieldUINT16Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set native_mesg_num field + /////////////////////////////////////////////////////////////////////// + void SetNativeMesgNum(FIT_MESG_NUM nativeMesgNum) + { + SetFieldUINT16Value(14, nativeMesgNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of native_field_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNativeFieldNumValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns native_field_num field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNativeFieldNum(void) const + { + return GetFieldUINT8Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set native_field_num field + /////////////////////////////////////////////////////////////////////// + void SetNativeFieldNum(FIT_UINT8 nativeFieldNum) + { + SetFieldUINT8Value(15, nativeFieldNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_FIELD_DESCRIPTION_MESG_HPP) diff --git a/fit_field_description_mesg_listener.hpp b/fit_field_description_mesg_listener.hpp new file mode 100644 index 0000000..58da4ce --- /dev/null +++ b/fit_field_description_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FIELD_DESCRIPTION_MESG_LISTENER_HPP) +#define FIT_FIELD_DESCRIPTION_MESG_LISTENER_HPP + +#include "fit_field_description_mesg.hpp" + +namespace fit +{ + +class FieldDescriptionMesgListener +{ +public: + virtual ~FieldDescriptionMesgListener() {} + virtual void OnMesg(FieldDescriptionMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_FIELD_DESCRIPTION_MESG_LISTENER_HPP) diff --git a/fit_file_capabilities_mesg.hpp b/fit_file_capabilities_mesg.hpp new file mode 100644 index 0000000..597841e --- /dev/null +++ b/fit_file_capabilities_mesg.hpp @@ -0,0 +1,236 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FILE_CAPABILITIES_MESG_HPP) +#define FIT_FILE_CAPABILITIES_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class FileCapabilitiesMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Type = 0; + static const FIT_UINT8 Flags = 1; + static const FIT_UINT8 Directory = 2; + static const FIT_UINT8 MaxCount = 3; + static const FIT_UINT8 MaxSize = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + FileCapabilitiesMesg(void) : Mesg(Profile::MESG_FILE_CAPABILITIES) + { + } + + FileCapabilitiesMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_FILE GetType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_FILE type) + { + SetFieldENUMValue(0, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of flags field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFlagsValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns flags field + /////////////////////////////////////////////////////////////////////// + FIT_FILE_FLAGS GetFlags(void) const + { + return GetFieldUINT8ZValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set flags field + /////////////////////////////////////////////////////////////////////// + void SetFlags(FIT_FILE_FLAGS flags) + { + SetFieldUINT8ZValue(1, flags, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of directory field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDirectoryValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns directory field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetDirectory(void) const + { + return GetFieldSTRINGValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set directory field + /////////////////////////////////////////////////////////////////////// + void SetDirectory(FIT_WSTRING directory) + { + SetFieldSTRINGValue(2, directory, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCountValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxCount(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_count field + /////////////////////////////////////////////////////////////////////// + void SetMaxCount(FIT_UINT16 maxCount) + { + SetFieldUINT16Value(3, maxCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_size field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSizeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_size field + // Units: bytes + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetMaxSize(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_size field + // Units: bytes + /////////////////////////////////////////////////////////////////////// + void SetMaxSize(FIT_UINT32 maxSize) + { + SetFieldUINT32Value(4, maxSize, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_FILE_CAPABILITIES_MESG_HPP) diff --git a/fit_file_capabilities_mesg_listener.hpp b/fit_file_capabilities_mesg_listener.hpp new file mode 100644 index 0000000..f5735f1 --- /dev/null +++ b/fit_file_capabilities_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FILE_CAPABILITIES_MESG_LISTENER_HPP) +#define FIT_FILE_CAPABILITIES_MESG_LISTENER_HPP + +#include "fit_file_capabilities_mesg.hpp" + +namespace fit +{ + +class FileCapabilitiesMesgListener +{ +public: + virtual ~FileCapabilitiesMesgListener() {} + virtual void OnMesg(FileCapabilitiesMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_FILE_CAPABILITIES_MESG_LISTENER_HPP) diff --git a/fit_file_creator_mesg.hpp b/fit_file_creator_mesg.hpp new file mode 100644 index 0000000..11d4711 --- /dev/null +++ b/fit_file_creator_mesg.hpp @@ -0,0 +1,106 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FILE_CREATOR_MESG_HPP) +#define FIT_FILE_CREATOR_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class FileCreatorMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 SoftwareVersion = 0; + static const FIT_UINT8 HardwareVersion = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + FileCreatorMesg(void) : Mesg(Profile::MESG_FILE_CREATOR) + { + } + + FileCreatorMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of software_version field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSoftwareVersionValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns software_version field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSoftwareVersion(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set software_version field + /////////////////////////////////////////////////////////////////////// + void SetSoftwareVersion(FIT_UINT16 softwareVersion) + { + SetFieldUINT16Value(0, softwareVersion, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hardware_version field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHardwareVersionValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hardware_version field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHardwareVersion(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hardware_version field + /////////////////////////////////////////////////////////////////////// + void SetHardwareVersion(FIT_UINT8 hardwareVersion) + { + SetFieldUINT8Value(1, hardwareVersion, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_FILE_CREATOR_MESG_HPP) diff --git a/fit_file_creator_mesg_listener.hpp b/fit_file_creator_mesg_listener.hpp new file mode 100644 index 0000000..353a676 --- /dev/null +++ b/fit_file_creator_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FILE_CREATOR_MESG_LISTENER_HPP) +#define FIT_FILE_CREATOR_MESG_LISTENER_HPP + +#include "fit_file_creator_mesg.hpp" + +namespace fit +{ + +class FileCreatorMesgListener +{ +public: + virtual ~FileCreatorMesgListener() {} + virtual void OnMesg(FileCreatorMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_FILE_CREATOR_MESG_LISTENER_HPP) diff --git a/fit_file_id_mesg.hpp b/fit_file_id_mesg.hpp new file mode 100644 index 0000000..d260cf9 --- /dev/null +++ b/fit_file_id_mesg.hpp @@ -0,0 +1,346 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FILE_ID_MESG_HPP) +#define FIT_FILE_ID_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class FileIdMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Type = 0; + static const FIT_UINT8 Manufacturer = 1; + static const FIT_UINT8 Product = 2; + static const FIT_UINT8 SerialNumber = 3; + static const FIT_UINT8 TimeCreated = 4; + static const FIT_UINT8 Number = 5; + static const FIT_UINT8 ProductName = 8; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + FileIdMesg(void) : Mesg(Profile::MESG_FILE_ID) + { + } + + FileIdMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_FILE GetType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_FILE type) + { + SetFieldENUMValue(0, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer field + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturer(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer field + /////////////////////////////////////////////////////////////////////// + void SetManufacturer(FIT_MANUFACTURER manufacturer) + { + SetFieldUINT16Value(1, manufacturer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProduct(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product field + /////////////////////////////////////////////////////////////////////// + void SetProduct(FIT_UINT16 product) + { + SetFieldUINT16Value(2, product, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of favero_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFaveroProductValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_FAVERO_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns favero_product field + /////////////////////////////////////////////////////////////////////// + FIT_FAVERO_PRODUCT GetFaveroProduct(void) const + { + return GetFieldUINT16Value(2, 0, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set favero_product field + /////////////////////////////////////////////////////////////////////// + void SetFaveroProduct(FIT_FAVERO_PRODUCT faveroProduct) + { + SetFieldUINT16Value(2, faveroProduct, 0, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of garmin_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGarminProductValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_GARMIN_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns garmin_product field + /////////////////////////////////////////////////////////////////////// + FIT_GARMIN_PRODUCT GetGarminProduct(void) const + { + return GetFieldUINT16Value(2, 0, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set garmin_product field + /////////////////////////////////////////////////////////////////////// + void SetGarminProduct(FIT_GARMIN_PRODUCT garminProduct) + { + SetFieldUINT16Value(2, garminProduct, 0, (FIT_UINT16) Profile::FILE_ID_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of serial_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSerialNumberValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns serial_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32Z GetSerialNumber(void) const + { + return GetFieldUINT32ZValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set serial_number field + /////////////////////////////////////////////////////////////////////// + void SetSerialNumber(FIT_UINT32Z serialNumber) + { + SetFieldUINT32ZValue(3, serialNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_created field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeCreatedValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_created field + // Comment: Only set for files that are can be created/erased. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimeCreated(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_created field + // Comment: Only set for files that are can be created/erased. + /////////////////////////////////////////////////////////////////////// + void SetTimeCreated(FIT_DATE_TIME timeCreated) + { + SetFieldUINT32Value(4, timeCreated, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumberValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number field + // Comment: Only set for files that are not created/erased. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumber(void) const + { + return GetFieldUINT16Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set number field + // Comment: Only set for files that are not created/erased. + /////////////////////////////////////////////////////////////////////// + void SetNumber(FIT_UINT16 number) + { + SetFieldUINT16Value(5, number, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductNameValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product_name field + // Comment: Optional free form string to indicate the devices name or model + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetProductName(void) const + { + return GetFieldSTRINGValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product_name field + // Comment: Optional free form string to indicate the devices name or model + /////////////////////////////////////////////////////////////////////// + void SetProductName(FIT_WSTRING productName) + { + SetFieldSTRINGValue(8, productName, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_FILE_ID_MESG_HPP) diff --git a/fit_file_id_mesg_listener.hpp b/fit_file_id_mesg_listener.hpp new file mode 100644 index 0000000..2cc4769 --- /dev/null +++ b/fit_file_id_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_FILE_ID_MESG_LISTENER_HPP) +#define FIT_FILE_ID_MESG_LISTENER_HPP + +#include "fit_file_id_mesg.hpp" + +namespace fit +{ + +class FileIdMesgListener +{ +public: + virtual ~FileIdMesgListener() {} + virtual void OnMesg(FileIdMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_FILE_ID_MESG_LISTENER_HPP) diff --git a/fit_goal_mesg.hpp b/fit_goal_mesg.hpp new file mode 100644 index 0000000..c21028c --- /dev/null +++ b/fit_goal_mesg.hpp @@ -0,0 +1,458 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_GOAL_MESG_HPP) +#define FIT_GOAL_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class GoalMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Sport = 0; + static const FIT_UINT8 SubSport = 1; + static const FIT_UINT8 StartDate = 2; + static const FIT_UINT8 EndDate = 3; + static const FIT_UINT8 Type = 4; + static const FIT_UINT8 Value = 5; + static const FIT_UINT8 Repeat = 6; + static const FIT_UINT8 TargetValue = 7; + static const FIT_UINT8 Recurrence = 8; + static const FIT_UINT8 RecurrenceValue = 9; + static const FIT_UINT8 Enabled = 10; + static const FIT_UINT8 Source = 11; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + GoalMesg(void) : Mesg(Profile::MESG_GOAL) + { + } + + GoalMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(0, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(1, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_date field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartDateValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_date field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartDate(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_date field + /////////////////////////////////////////////////////////////////////// + void SetStartDate(FIT_DATE_TIME startDate) + { + SetFieldUINT32Value(2, startDate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_date field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndDateValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_date field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetEndDate(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_date field + /////////////////////////////////////////////////////////////////////// + void SetEndDate(FIT_DATE_TIME endDate) + { + SetFieldUINT32Value(3, endDate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_GOAL GetType(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_GOAL type) + { + SetFieldENUMValue(4, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsValueValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns value field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetValue(void) const + { + return GetFieldUINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set value field + /////////////////////////////////////////////////////////////////////// + void SetValue(FIT_UINT32 value) + { + SetFieldUINT32Value(5, value, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repeat field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetRepeat(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat field + /////////////////////////////////////////////////////////////////////// + void SetRepeat(FIT_BOOL repeat) + { + SetFieldENUMValue(6, repeat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetValueValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns target_value field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetValue(void) const + { + return GetFieldUINT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_value field + /////////////////////////////////////////////////////////////////////// + void SetTargetValue(FIT_UINT32 targetValue) + { + SetFieldUINT32Value(7, targetValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of recurrence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRecurrenceValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns recurrence field + /////////////////////////////////////////////////////////////////////// + FIT_GOAL_RECURRENCE GetRecurrence(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set recurrence field + /////////////////////////////////////////////////////////////////////// + void SetRecurrence(FIT_GOAL_RECURRENCE recurrence) + { + SetFieldENUMValue(8, recurrence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of recurrence_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRecurrenceValueValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns recurrence_value field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRecurrenceValue(void) const + { + return GetFieldUINT16Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set recurrence_value field + /////////////////////////////////////////////////////////////////////// + void SetRecurrenceValue(FIT_UINT16 recurrenceValue) + { + SetFieldUINT16Value(9, recurrenceValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(10, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of source field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSourceValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns source field + /////////////////////////////////////////////////////////////////////// + FIT_GOAL_SOURCE GetSource(void) const + { + return GetFieldENUMValue(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set source field + /////////////////////////////////////////////////////////////////////// + void SetSource(FIT_GOAL_SOURCE source) + { + SetFieldENUMValue(11, source, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_GOAL_MESG_HPP) diff --git a/fit_goal_mesg_listener.hpp b/fit_goal_mesg_listener.hpp new file mode 100644 index 0000000..eb97e6f --- /dev/null +++ b/fit_goal_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_GOAL_MESG_LISTENER_HPP) +#define FIT_GOAL_MESG_LISTENER_HPP + +#include "fit_goal_mesg.hpp" + +namespace fit +{ + +class GoalMesgListener +{ +public: + virtual ~GoalMesgListener() {} + virtual void OnMesg(GoalMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_GOAL_MESG_LISTENER_HPP) diff --git a/fit_gps_metadata_mesg.hpp b/fit_gps_metadata_mesg.hpp new file mode 100644 index 0000000..f0d8e45 --- /dev/null +++ b/fit_gps_metadata_mesg.hpp @@ -0,0 +1,364 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_GPS_METADATA_MESG_HPP) +#define FIT_GPS_METADATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class GpsMetadataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 PositionLat = 1; + static const FIT_UINT8 PositionLong = 2; + static const FIT_UINT8 EnhancedAltitude = 3; + static const FIT_UINT8 EnhancedSpeed = 4; + static const FIT_UINT8 Heading = 5; + static const FIT_UINT8 UtcTimestamp = 6; + static const FIT_UINT8 Velocity = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + GpsMetadataMesg(void) : Mesg(Profile::MESG_GPS_METADATA) + { + } + + GpsMetadataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLatValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLat(void) const + { + return GetFieldSINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLat(FIT_SINT32 positionLat) + { + SetFieldSINT32Value(1, positionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLongValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLong(void) const + { + return GetFieldSINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLong(FIT_SINT32 positionLong) + { + SetFieldSINT32Value(2, positionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAltitudeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAltitude(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAltitude(FIT_FLOAT32 enhancedAltitude) + { + SetFieldFLOAT32Value(3, enhancedAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedSpeedValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedSpeed(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetEnhancedSpeed(FIT_FLOAT32 enhancedSpeed) + { + SetFieldFLOAT32Value(4, enhancedSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heading field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeadingValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heading field + // Units: degrees + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetHeading(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heading field + // Units: degrees + /////////////////////////////////////////////////////////////////////// + void SetHeading(FIT_FLOAT32 heading) + { + SetFieldFLOAT32Value(5, heading, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of utc_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUtcTimestampValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns utc_timestamp field + // Units: s + // Comment: Used to correlate UTC to system time if the timestamp of the message is in system time. This UTC time is derived from the GPS data. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetUtcTimestamp(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set utc_timestamp field + // Units: s + // Comment: Used to correlate UTC to system time if the timestamp of the message is in system time. This UTC time is derived from the GPS data. + /////////////////////////////////////////////////////////////////////// + void SetUtcTimestamp(FIT_DATE_TIME utcTimestamp) + { + SetFieldUINT32Value(6, utcTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of velocity + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumVelocity(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of velocity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVelocityValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns velocity field + // Units: m/s + // Comment: velocity[0] is lon velocity. Velocity[1] is lat velocity. Velocity[2] is altitude velocity. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVelocity(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set velocity field + // Units: m/s + // Comment: velocity[0] is lon velocity. Velocity[1] is lat velocity. Velocity[2] is altitude velocity. + /////////////////////////////////////////////////////////////////////// + void SetVelocity(FIT_UINT8 index, FIT_FLOAT32 velocity) + { + SetFieldFLOAT32Value(7, velocity, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_GPS_METADATA_MESG_HPP) diff --git a/fit_gps_metadata_mesg_listener.hpp b/fit_gps_metadata_mesg_listener.hpp new file mode 100644 index 0000000..36c2f12 --- /dev/null +++ b/fit_gps_metadata_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_GPS_METADATA_MESG_LISTENER_HPP) +#define FIT_GPS_METADATA_MESG_LISTENER_HPP + +#include "fit_gps_metadata_mesg.hpp" + +namespace fit +{ + +class GpsMetadataMesgListener +{ +public: + virtual ~GpsMetadataMesgListener() {} + virtual void OnMesg(GpsMetadataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_GPS_METADATA_MESG_LISTENER_HPP) diff --git a/fit_gyroscope_data_mesg.hpp b/fit_gyroscope_data_mesg.hpp new file mode 100644 index 0000000..ca0ffb7 --- /dev/null +++ b/fit_gyroscope_data_mesg.hpp @@ -0,0 +1,422 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_GYROSCOPE_DATA_MESG_HPP) +#define FIT_GYROSCOPE_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class GyroscopeDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SampleTimeOffset = 1; + static const FIT_UINT8 GyroX = 2; + static const FIT_UINT8 GyroY = 3; + static const FIT_UINT8 GyroZ = 4; + static const FIT_UINT8 CalibratedGyroX = 5; + static const FIT_UINT8 CalibratedGyroY = 6; + static const FIT_UINT8 CalibratedGyroZ = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + GyroscopeDataMesg(void) : Mesg(Profile::MESG_GYROSCOPE_DATA) + { + } + + GyroscopeDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of sample_time_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSampleTimeOffset(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sample_time_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSampleTimeOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the gyro sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in gyro_x and gyro_y and gyro_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSampleTimeOffset(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the gyro sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in gyro_x and gyro_y and gyro_z + /////////////////////////////////////////////////////////////////////// + void SetSampleTimeOffset(FIT_UINT8 index, FIT_UINT16 sampleTimeOffset) + { + SetFieldUINT16Value(1, sampleTimeOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gyro_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGyroX(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroXValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_x field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetGyroX(FIT_UINT8 index) const + { + return GetFieldUINT16Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_x field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetGyroX(FIT_UINT8 index, FIT_UINT16 gyroX) + { + SetFieldUINT16Value(2, gyroX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gyro_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGyroY(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroYValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_y field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetGyroY(FIT_UINT8 index) const + { + return GetFieldUINT16Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_y field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetGyroY(FIT_UINT8 index, FIT_UINT16 gyroY) + { + SetFieldUINT16Value(3, gyroY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gyro_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGyroZ(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroZValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_z field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetGyroZ(FIT_UINT8 index) const + { + return GetFieldUINT16Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_z field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetGyroZ(FIT_UINT8 index, FIT_UINT16 gyroZ) + { + SetFieldUINT16Value(4, gyroZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_gyro_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedGyroX(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_gyro_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedGyroXValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_gyro_x field + // Units: deg/s + // Comment: Calibrated gyro reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedGyroX(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_gyro_x field + // Units: deg/s + // Comment: Calibrated gyro reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedGyroX(FIT_UINT8 index, FIT_FLOAT32 calibratedGyroX) + { + SetFieldFLOAT32Value(5, calibratedGyroX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_gyro_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedGyroY(void) const + { + return GetFieldNumValues(6, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_gyro_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedGyroYValid(FIT_UINT8 index) const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_gyro_y field + // Units: deg/s + // Comment: Calibrated gyro reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedGyroY(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(6, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_gyro_y field + // Units: deg/s + // Comment: Calibrated gyro reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedGyroY(FIT_UINT8 index, FIT_FLOAT32 calibratedGyroY) + { + SetFieldFLOAT32Value(6, calibratedGyroY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_gyro_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedGyroZ(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_gyro_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedGyroZValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_gyro_z field + // Units: deg/s + // Comment: Calibrated gyro reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedGyroZ(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_gyro_z field + // Units: deg/s + // Comment: Calibrated gyro reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedGyroZ(FIT_UINT8 index, FIT_FLOAT32 calibratedGyroZ) + { + SetFieldFLOAT32Value(7, calibratedGyroZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_GYROSCOPE_DATA_MESG_HPP) diff --git a/fit_gyroscope_data_mesg_listener.hpp b/fit_gyroscope_data_mesg_listener.hpp new file mode 100644 index 0000000..5831406 --- /dev/null +++ b/fit_gyroscope_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_GYROSCOPE_DATA_MESG_LISTENER_HPP) +#define FIT_GYROSCOPE_DATA_MESG_LISTENER_HPP + +#include "fit_gyroscope_data_mesg.hpp" + +namespace fit +{ + +class GyroscopeDataMesgListener +{ +public: + virtual ~GyroscopeDataMesgListener() {} + virtual void OnMesg(GyroscopeDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_GYROSCOPE_DATA_MESG_LISTENER_HPP) diff --git a/fit_hr_mesg.hpp b/fit_hr_mesg.hpp new file mode 100644 index 0000000..f061df9 --- /dev/null +++ b/fit_hr_mesg.hpp @@ -0,0 +1,266 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HR_MESG_HPP) +#define FIT_HR_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HrMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 FractionalTimestamp = 0; + static const FIT_UINT8 Time256 = 1; + static const FIT_UINT8 FilteredBpm = 6; + static const FIT_UINT8 EventTimestamp = 9; + static const FIT_UINT8 EventTimestamp12 = 10; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HrMesg(void) : Mesg(Profile::MESG_HR) + { + } + + HrMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fractional_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFractionalTimestampValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fractional_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFractionalTimestamp(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fractional_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetFractionalTimestamp(FIT_FLOAT32 fractionalTimestamp) + { + SetFieldFLOAT32Value(0, fractionalTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time256 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTime256Valid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time256 field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTime256(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time256 field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTime256(FIT_FLOAT32 time256) + { + SetFieldFLOAT32Value(1, time256, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of filtered_bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumFilteredBpm(void) const + { + return GetFieldNumValues(6, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of filtered_bpm field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFilteredBpmValid(FIT_UINT8 index) const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns filtered_bpm field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFilteredBpm(FIT_UINT8 index) const + { + return GetFieldUINT8Value(6, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set filtered_bpm field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetFilteredBpm(FIT_UINT8 index, FIT_UINT8 filteredBpm) + { + SetFieldUINT8Value(6, filteredBpm, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of event_timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumEventTimestamp(void) const + { + return GetFieldNumValues(9, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTimestampValid(FIT_UINT8 index) const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEventTimestamp(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(9, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetEventTimestamp(FIT_UINT8 index, FIT_FLOAT32 eventTimestamp) + { + SetFieldFLOAT32Value(9, eventTimestamp, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of event_timestamp_12 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumEventTimestamp12(void) const + { + return GetFieldNumValues(10, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_timestamp_12 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTimestamp12Valid(FIT_UINT8 index) const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_timestamp_12 field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetEventTimestamp12(FIT_UINT8 index) const + { + return GetFieldBYTEValue(10, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_timestamp_12 field + /////////////////////////////////////////////////////////////////////// + void SetEventTimestamp12(FIT_UINT8 index, FIT_BYTE eventTimestamp12) + { + SetFieldBYTEValue(10, eventTimestamp12, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HR_MESG_HPP) diff --git a/fit_hr_mesg_listener.hpp b/fit_hr_mesg_listener.hpp new file mode 100644 index 0000000..9dc29e1 --- /dev/null +++ b/fit_hr_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HR_MESG_LISTENER_HPP) +#define FIT_HR_MESG_LISTENER_HPP + +#include "fit_hr_mesg.hpp" + +namespace fit +{ + +class HrMesgListener +{ +public: + virtual ~HrMesgListener() {} + virtual void OnMesg(HrMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HR_MESG_LISTENER_HPP) diff --git a/fit_hr_zone_mesg.hpp b/fit_hr_zone_mesg.hpp new file mode 100644 index 0000000..f95e20b --- /dev/null +++ b/fit_hr_zone_mesg.hpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HR_ZONE_MESG_HPP) +#define FIT_HR_ZONE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HrZoneMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 HighBpm = 1; + static const FIT_UINT8 Name = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HrZoneMesg(void) : Mesg(Profile::MESG_HR_ZONE) + { + } + + HrZoneMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of high_bpm field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHighBpmValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns high_bpm field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHighBpm(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set high_bpm field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHighBpm(FIT_UINT8 highBpm) + { + SetFieldUINT8Value(1, highBpm, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(2, name, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HR_ZONE_MESG_HPP) diff --git a/fit_hr_zone_mesg_listener.hpp b/fit_hr_zone_mesg_listener.hpp new file mode 100644 index 0000000..42fe352 --- /dev/null +++ b/fit_hr_zone_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HR_ZONE_MESG_LISTENER_HPP) +#define FIT_HR_ZONE_MESG_LISTENER_HPP + +#include "fit_hr_zone_mesg.hpp" + +namespace fit +{ + +class HrZoneMesgListener +{ +public: + virtual ~HrZoneMesgListener() {} + virtual void OnMesg(HrZoneMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HR_ZONE_MESG_LISTENER_HPP) diff --git a/fit_hrm_profile_mesg.hpp b/fit_hrm_profile_mesg.hpp new file mode 100644 index 0000000..62ceaff --- /dev/null +++ b/fit_hrm_profile_mesg.hpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRM_PROFILE_MESG_HPP) +#define FIT_HRM_PROFILE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HrmProfileMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Enabled = 0; + static const FIT_UINT8 HrmAntId = 1; + static const FIT_UINT8 LogHrv = 2; + static const FIT_UINT8 HrmAntIdTransType = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HrmProfileMesg(void) : Mesg(Profile::MESG_HRM_PROFILE) + { + } + + HrmProfileMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(0, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hrm_ant_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrmAntIdValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hrm_ant_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetHrmAntId(void) const + { + return GetFieldUINT16ZValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hrm_ant_id field + /////////////////////////////////////////////////////////////////////// + void SetHrmAntId(FIT_UINT16Z hrmAntId) + { + SetFieldUINT16ZValue(1, hrmAntId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of log_hrv field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLogHrvValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns log_hrv field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetLogHrv(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set log_hrv field + /////////////////////////////////////////////////////////////////////// + void SetLogHrv(FIT_BOOL logHrv) + { + SetFieldENUMValue(2, logHrv, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hrm_ant_id_trans_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrmAntIdTransTypeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hrm_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetHrmAntIdTransType(void) const + { + return GetFieldUINT8ZValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hrm_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + void SetHrmAntIdTransType(FIT_UINT8Z hrmAntIdTransType) + { + SetFieldUINT8ZValue(3, hrmAntIdTransType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HRM_PROFILE_MESG_HPP) diff --git a/fit_hrm_profile_mesg_listener.hpp b/fit_hrm_profile_mesg_listener.hpp new file mode 100644 index 0000000..28b25fb --- /dev/null +++ b/fit_hrm_profile_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRM_PROFILE_MESG_LISTENER_HPP) +#define FIT_HRM_PROFILE_MESG_LISTENER_HPP + +#include "fit_hrm_profile_mesg.hpp" + +namespace fit +{ + +class HrmProfileMesgListener +{ +public: + virtual ~HrmProfileMesgListener() {} + virtual void OnMesg(HrmProfileMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HRM_PROFILE_MESG_LISTENER_HPP) diff --git a/fit_hrv_mesg.hpp b/fit_hrv_mesg.hpp new file mode 100644 index 0000000..d8c8f93 --- /dev/null +++ b/fit_hrv_mesg.hpp @@ -0,0 +1,86 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRV_MESG_HPP) +#define FIT_HRV_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HrvMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Time = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HrvMesg(void) : Mesg(Profile::MESG_HRV) + { + } + + HrvMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTime(void) const + { + return GetFieldNumValues(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time field + // Units: s + // Comment: Time between beats + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTime(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(0, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time field + // Units: s + // Comment: Time between beats + /////////////////////////////////////////////////////////////////////// + void SetTime(FIT_UINT8 index, FIT_FLOAT32 time) + { + SetFieldFLOAT32Value(0, time, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HRV_MESG_HPP) diff --git a/fit_hrv_mesg_listener.hpp b/fit_hrv_mesg_listener.hpp new file mode 100644 index 0000000..9dfb409 --- /dev/null +++ b/fit_hrv_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRV_MESG_LISTENER_HPP) +#define FIT_HRV_MESG_LISTENER_HPP + +#include "fit_hrv_mesg.hpp" + +namespace fit +{ + +class HrvMesgListener +{ +public: + virtual ~HrvMesgListener() {} + virtual void OnMesg(HrvMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HRV_MESG_LISTENER_HPP) diff --git a/fit_hrv_status_summary_mesg.hpp b/fit_hrv_status_summary_mesg.hpp new file mode 100644 index 0000000..d82de7d --- /dev/null +++ b/fit_hrv_status_summary_mesg.hpp @@ -0,0 +1,322 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRV_STATUS_SUMMARY_MESG_HPP) +#define FIT_HRV_STATUS_SUMMARY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HrvStatusSummaryMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 WeeklyAverage = 0; + static const FIT_UINT8 LastNightAverage = 1; + static const FIT_UINT8 LastNight5MinHigh = 2; + static const FIT_UINT8 BaselineLowUpper = 3; + static const FIT_UINT8 BaselineBalancedLower = 4; + static const FIT_UINT8 BaselineBalancedUpper = 5; + static const FIT_UINT8 Status = 6; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HrvStatusSummaryMesg(void) : Mesg(Profile::MESG_HRV_STATUS_SUMMARY) + { + } + + HrvStatusSummaryMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weekly_average field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeeklyAverageValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weekly_average field + // Units: ms + // Comment: 7 day RMSSD average over sleep + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetWeeklyAverage(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weekly_average field + // Units: ms + // Comment: 7 day RMSSD average over sleep + /////////////////////////////////////////////////////////////////////// + void SetWeeklyAverage(FIT_FLOAT32 weeklyAverage) + { + SetFieldFLOAT32Value(0, weeklyAverage, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of last_night_average field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLastNightAverageValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns last_night_average field + // Units: ms + // Comment: Last night RMSSD average over sleep + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLastNightAverage(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set last_night_average field + // Units: ms + // Comment: Last night RMSSD average over sleep + /////////////////////////////////////////////////////////////////////// + void SetLastNightAverage(FIT_FLOAT32 lastNightAverage) + { + SetFieldFLOAT32Value(1, lastNightAverage, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of last_night_5_min_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLastNight5MinHighValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns last_night_5_min_high field + // Units: ms + // Comment: 5 minute high RMSSD value over sleep + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLastNight5MinHigh(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set last_night_5_min_high field + // Units: ms + // Comment: 5 minute high RMSSD value over sleep + /////////////////////////////////////////////////////////////////////// + void SetLastNight5MinHigh(FIT_FLOAT32 lastNight5MinHigh) + { + SetFieldFLOAT32Value(2, lastNight5MinHigh, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of baseline_low_upper field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBaselineLowUpperValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns baseline_low_upper field + // Units: ms + // Comment: 3 week baseline, upper boundary of low HRV status + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBaselineLowUpper(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set baseline_low_upper field + // Units: ms + // Comment: 3 week baseline, upper boundary of low HRV status + /////////////////////////////////////////////////////////////////////// + void SetBaselineLowUpper(FIT_FLOAT32 baselineLowUpper) + { + SetFieldFLOAT32Value(3, baselineLowUpper, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of baseline_balanced_lower field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBaselineBalancedLowerValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns baseline_balanced_lower field + // Units: ms + // Comment: 3 week baseline, lower boundary of balanced HRV status + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBaselineBalancedLower(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set baseline_balanced_lower field + // Units: ms + // Comment: 3 week baseline, lower boundary of balanced HRV status + /////////////////////////////////////////////////////////////////////// + void SetBaselineBalancedLower(FIT_FLOAT32 baselineBalancedLower) + { + SetFieldFLOAT32Value(4, baselineBalancedLower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of baseline_balanced_upper field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBaselineBalancedUpperValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns baseline_balanced_upper field + // Units: ms + // Comment: 3 week baseline, upper boundary of balanced HRV status + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBaselineBalancedUpper(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set baseline_balanced_upper field + // Units: ms + // Comment: 3 week baseline, upper boundary of balanced HRV status + /////////////////////////////////////////////////////////////////////// + void SetBaselineBalancedUpper(FIT_FLOAT32 baselineBalancedUpper) + { + SetFieldFLOAT32Value(5, baselineBalancedUpper, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStatusValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns status field + /////////////////////////////////////////////////////////////////////// + FIT_HRV_STATUS GetStatus(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set status field + /////////////////////////////////////////////////////////////////////// + void SetStatus(FIT_HRV_STATUS status) + { + SetFieldENUMValue(6, status, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HRV_STATUS_SUMMARY_MESG_HPP) diff --git a/fit_hrv_status_summary_mesg_listener.hpp b/fit_hrv_status_summary_mesg_listener.hpp new file mode 100644 index 0000000..b4d1f32 --- /dev/null +++ b/fit_hrv_status_summary_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRV_STATUS_SUMMARY_MESG_LISTENER_HPP) +#define FIT_HRV_STATUS_SUMMARY_MESG_LISTENER_HPP + +#include "fit_hrv_status_summary_mesg.hpp" + +namespace fit +{ + +class HrvStatusSummaryMesgListener +{ +public: + virtual ~HrvStatusSummaryMesgListener() {} + virtual void OnMesg(HrvStatusSummaryMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HRV_STATUS_SUMMARY_MESG_LISTENER_HPP) diff --git a/fit_hrv_value_mesg.hpp b/fit_hrv_value_mesg.hpp new file mode 100644 index 0000000..e63ad82 --- /dev/null +++ b/fit_hrv_value_mesg.hpp @@ -0,0 +1,110 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRV_VALUE_MESG_HPP) +#define FIT_HRV_VALUE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HrvValueMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Value = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HrvValueMesg(void) : Mesg(Profile::MESG_HRV_VALUE) + { + } + + HrvValueMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsValueValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns value field + // Units: ms + // Comment: 5 minute RMSSD + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetValue(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set value field + // Units: ms + // Comment: 5 minute RMSSD + /////////////////////////////////////////////////////////////////////// + void SetValue(FIT_FLOAT32 value) + { + SetFieldFLOAT32Value(0, value, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HRV_VALUE_MESG_HPP) diff --git a/fit_hrv_value_mesg_listener.hpp b/fit_hrv_value_mesg_listener.hpp new file mode 100644 index 0000000..622e5cb --- /dev/null +++ b/fit_hrv_value_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HRV_VALUE_MESG_LISTENER_HPP) +#define FIT_HRV_VALUE_MESG_LISTENER_HPP + +#include "fit_hrv_value_mesg.hpp" + +namespace fit +{ + +class HrvValueMesgListener +{ +public: + virtual ~HrvValueMesgListener() {} + virtual void OnMesg(HrvValueMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HRV_VALUE_MESG_LISTENER_HPP) diff --git a/fit_hsa_accelerometer_data_mesg.hpp b/fit_hsa_accelerometer_data_mesg.hpp new file mode 100644 index 0000000..a72b817 --- /dev/null +++ b/fit_hsa_accelerometer_data_mesg.hpp @@ -0,0 +1,314 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_ACCELEROMETER_DATA_MESG_HPP) +#define FIT_HSA_ACCELEROMETER_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaAccelerometerDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SamplingInterval = 1; + static const FIT_UINT8 AccelX = 2; + static const FIT_UINT8 AccelY = 3; + static const FIT_UINT8 AccelZ = 4; + static const FIT_UINT8 Timestamp32k = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaAccelerometerDataMesg(void) : Mesg(Profile::MESG_HSA_ACCELEROMETER_DATA) + { + } + + HsaAccelerometerDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond resolution of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond resolution of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sampling_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSamplingIntervalValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sampling_interval field + // Units: ms + // Comment: Sampling Interval in Milliseconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSamplingInterval(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sampling_interval field + // Units: ms + // Comment: Sampling Interval in Milliseconds + /////////////////////////////////////////////////////////////////////// + void SetSamplingInterval(FIT_UINT16 samplingInterval) + { + SetFieldUINT16Value(1, samplingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelX(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelXValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_x field + // Units: mG + // Comment: X-Axis Measurement + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAccelX(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_x field + // Units: mG + // Comment: X-Axis Measurement + /////////////////////////////////////////////////////////////////////// + void SetAccelX(FIT_UINT8 index, FIT_FLOAT32 accelX) + { + SetFieldFLOAT32Value(2, accelX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelY(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelYValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_y field + // Units: mG + // Comment: Y-Axis Measurement + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAccelY(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_y field + // Units: mG + // Comment: Y-Axis Measurement + /////////////////////////////////////////////////////////////////////// + void SetAccelY(FIT_UINT8 index, FIT_FLOAT32 accelY) + { + SetFieldFLOAT32Value(3, accelY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of accel_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAccelZ(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelZValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accel_z field + // Units: mG + // Comment: Z-Axis Measurement + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAccelZ(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_z field + // Units: mG + // Comment: Z-Axis Measurement + /////////////////////////////////////////////////////////////////////// + void SetAccelZ(FIT_UINT8 index, FIT_FLOAT32 accelZ) + { + SetFieldFLOAT32Value(4, accelZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_32k field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestamp32kValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_32k field + // Comment: 32 kHz timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTimestamp32k(void) const + { + return GetFieldUINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_32k field + // Comment: 32 kHz timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp32k(FIT_UINT32 timestamp32k) + { + SetFieldUINT32Value(5, timestamp32k, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_ACCELEROMETER_DATA_MESG_HPP) diff --git a/fit_hsa_accelerometer_data_mesg_listener.hpp b/fit_hsa_accelerometer_data_mesg_listener.hpp new file mode 100644 index 0000000..dee4746 --- /dev/null +++ b/fit_hsa_accelerometer_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_ACCELEROMETER_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_ACCELEROMETER_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_accelerometer_data_mesg.hpp" + +namespace fit +{ + +class HsaAccelerometerDataMesgListener +{ +public: + virtual ~HsaAccelerometerDataMesgListener() {} + virtual void OnMesg(HsaAccelerometerDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_ACCELEROMETER_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_body_battery_data_mesg.hpp b/fit_hsa_body_battery_data_mesg.hpp new file mode 100644 index 0000000..abcb84e --- /dev/null +++ b/fit_hsa_body_battery_data_mesg.hpp @@ -0,0 +1,240 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_BODY_BATTERY_DATA_MESG_HPP) +#define FIT_HSA_BODY_BATTERY_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaBodyBatteryDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 Level = 1; + static const FIT_UINT8 Charged = 2; + static const FIT_UINT8 Uncharged = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaBodyBatteryDataMesg(void) : Mesg(Profile::MESG_HSA_BODY_BATTERY_DATA) + { + } + + HsaBodyBatteryDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of level + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLevel(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLevelValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns level field + // Units: percent + // Comment: Body battery level: [0,100] Blank: -16 + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetLevel(FIT_UINT8 index) const + { + return GetFieldSINT8Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set level field + // Units: percent + // Comment: Body battery level: [0,100] Blank: -16 + /////////////////////////////////////////////////////////////////////// + void SetLevel(FIT_UINT8 index, FIT_SINT8 level) + { + SetFieldSINT8Value(1, level, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of charged + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCharged(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of charged field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsChargedValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns charged field + // Comment: Body battery charged value + /////////////////////////////////////////////////////////////////////// + FIT_SINT16 GetCharged(FIT_UINT8 index) const + { + return GetFieldSINT16Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set charged field + // Comment: Body battery charged value + /////////////////////////////////////////////////////////////////////// + void SetCharged(FIT_UINT8 index, FIT_SINT16 charged) + { + SetFieldSINT16Value(2, charged, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of uncharged + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumUncharged(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of uncharged field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUnchargedValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns uncharged field + // Comment: Body battery uncharged value + /////////////////////////////////////////////////////////////////////// + FIT_SINT16 GetUncharged(FIT_UINT8 index) const + { + return GetFieldSINT16Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set uncharged field + // Comment: Body battery uncharged value + /////////////////////////////////////////////////////////////////////// + void SetUncharged(FIT_UINT8 index, FIT_SINT16 uncharged) + { + SetFieldSINT16Value(3, uncharged, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_BODY_BATTERY_DATA_MESG_HPP) diff --git a/fit_hsa_body_battery_data_mesg_listener.hpp b/fit_hsa_body_battery_data_mesg_listener.hpp new file mode 100644 index 0000000..2b2047a --- /dev/null +++ b/fit_hsa_body_battery_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_BODY_BATTERY_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_BODY_BATTERY_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_body_battery_data_mesg.hpp" + +namespace fit +{ + +class HsaBodyBatteryDataMesgListener +{ +public: + virtual ~HsaBodyBatteryDataMesgListener() {} + virtual void OnMesg(HsaBodyBatteryDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_BODY_BATTERY_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_configuration_data_mesg.hpp b/fit_hsa_configuration_data_mesg.hpp new file mode 100644 index 0000000..58b001c --- /dev/null +++ b/fit_hsa_configuration_data_mesg.hpp @@ -0,0 +1,154 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_CONFIGURATION_DATA_MESG_HPP) +#define FIT_HSA_CONFIGURATION_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaConfigurationDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Data = 0; + static const FIT_UINT8 DataSize = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaConfigurationDataMesg(void) : Mesg(Profile::MESG_HSA_CONFIGURATION_DATA) + { + } + + HsaConfigurationDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Encoded configuration data + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Encoded configuration data + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumData(void) const + { + return GetFieldNumValues(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data field + // Comment: Encoded configuration data. Health SDK use only + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetData(FIT_UINT8 index) const + { + return GetFieldBYTEValue(0, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data field + // Comment: Encoded configuration data. Health SDK use only + /////////////////////////////////////////////////////////////////////// + void SetData(FIT_UINT8 index, FIT_BYTE data) + { + SetFieldBYTEValue(0, data, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data_size field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataSizeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data_size field + // Comment: Size in bytes of data field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDataSize(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data_size field + // Comment: Size in bytes of data field + /////////////////////////////////////////////////////////////////////// + void SetDataSize(FIT_UINT8 dataSize) + { + SetFieldUINT8Value(1, dataSize, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_CONFIGURATION_DATA_MESG_HPP) diff --git a/fit_hsa_configuration_data_mesg_listener.hpp b/fit_hsa_configuration_data_mesg_listener.hpp new file mode 100644 index 0000000..9298e64 --- /dev/null +++ b/fit_hsa_configuration_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_CONFIGURATION_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_CONFIGURATION_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_configuration_data_mesg.hpp" + +namespace fit +{ + +class HsaConfigurationDataMesgListener +{ +public: + virtual ~HsaConfigurationDataMesgListener() {} + virtual void OnMesg(HsaConfigurationDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_CONFIGURATION_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_event_mesg.hpp b/fit_hsa_event_mesg.hpp new file mode 100644 index 0000000..e9e1958 --- /dev/null +++ b/fit_hsa_event_mesg.hpp @@ -0,0 +1,110 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_EVENT_MESG_HPP) +#define FIT_HSA_EVENT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaEventMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 EventId = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaEventMesg(void) : Mesg(Profile::MESG_HSA_EVENT) + { + } + + HsaEventMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventIdValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_id field + // Comment: Event ID. Health SDK use only + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventId(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_id field + // Comment: Event ID. Health SDK use only + /////////////////////////////////////////////////////////////////////// + void SetEventId(FIT_UINT8 eventId) + { + SetFieldUINT8Value(0, eventId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_EVENT_MESG_HPP) diff --git a/fit_hsa_event_mesg_listener.hpp b/fit_hsa_event_mesg_listener.hpp new file mode 100644 index 0000000..b5fd91e --- /dev/null +++ b/fit_hsa_event_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_EVENT_MESG_LISTENER_HPP) +#define FIT_HSA_EVENT_MESG_LISTENER_HPP + +#include "fit_hsa_event_mesg.hpp" + +namespace fit +{ + +class HsaEventMesgListener +{ +public: + virtual ~HsaEventMesgListener() {} + virtual void OnMesg(HsaEventMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_EVENT_MESG_LISTENER_HPP) diff --git a/fit_hsa_gyroscope_data_mesg.hpp b/fit_hsa_gyroscope_data_mesg.hpp new file mode 100644 index 0000000..0259d15 --- /dev/null +++ b/fit_hsa_gyroscope_data_mesg.hpp @@ -0,0 +1,316 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_GYROSCOPE_DATA_MESG_HPP) +#define FIT_HSA_GYROSCOPE_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaGyroscopeDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SamplingInterval = 1; + static const FIT_UINT8 GyroX = 2; + static const FIT_UINT8 GyroY = 3; + static const FIT_UINT8 GyroZ = 4; + static const FIT_UINT8 Timestamp32k = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaGyroscopeDataMesg(void) : Mesg(Profile::MESG_HSA_GYROSCOPE_DATA) + { + } + + HsaGyroscopeDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond resolution of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond resolution of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sampling_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSamplingIntervalValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sampling_interval field + // Units: 1/32768 s + // Comment: Sampling Interval in 32 kHz timescale + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSamplingInterval(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sampling_interval field + // Units: 1/32768 s + // Comment: Sampling Interval in 32 kHz timescale + /////////////////////////////////////////////////////////////////////// + void SetSamplingInterval(FIT_UINT16 samplingInterval) + { + SetFieldUINT16Value(1, samplingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gyro_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGyroX(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroXValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_x field + // Units: deg/s + // Comment: X-Axis Measurement + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetGyroX(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_x field + // Units: deg/s + // Comment: X-Axis Measurement + /////////////////////////////////////////////////////////////////////// + void SetGyroX(FIT_UINT8 index, FIT_FLOAT32 gyroX) + { + SetFieldFLOAT32Value(2, gyroX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gyro_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGyroY(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroYValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_y field + // Units: deg/s + // Comment: Y-Axis Measurement + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetGyroY(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_y field + // Units: deg/s + // Comment: Y-Axis Measurement + /////////////////////////////////////////////////////////////////////// + void SetGyroY(FIT_UINT8 index, FIT_FLOAT32 gyroY) + { + SetFieldFLOAT32Value(3, gyroY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gyro_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGyroZ(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroZValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_z field + // Units: deg/s + // Comment: Z-Axis Measurement + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetGyroZ(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_z field + // Units: deg/s + // Comment: Z-Axis Measurement + /////////////////////////////////////////////////////////////////////// + void SetGyroZ(FIT_UINT8 index, FIT_FLOAT32 gyroZ) + { + SetFieldFLOAT32Value(4, gyroZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_32k field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestamp32kValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_32k field + // Units: 1/32768 s + // Comment: 32 kHz timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTimestamp32k(void) const + { + return GetFieldUINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_32k field + // Units: 1/32768 s + // Comment: 32 kHz timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp32k(FIT_UINT32 timestamp32k) + { + SetFieldUINT32Value(5, timestamp32k, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_GYROSCOPE_DATA_MESG_HPP) diff --git a/fit_hsa_gyroscope_data_mesg_listener.hpp b/fit_hsa_gyroscope_data_mesg_listener.hpp new file mode 100644 index 0000000..b28c992 --- /dev/null +++ b/fit_hsa_gyroscope_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_GYROSCOPE_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_GYROSCOPE_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_gyroscope_data_mesg.hpp" + +namespace fit +{ + +class HsaGyroscopeDataMesgListener +{ +public: + virtual ~HsaGyroscopeDataMesgListener() {} + virtual void OnMesg(HsaGyroscopeDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_GYROSCOPE_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_heart_rate_data_mesg.hpp b/fit_hsa_heart_rate_data_mesg.hpp new file mode 100644 index 0000000..f634f61 --- /dev/null +++ b/fit_hsa_heart_rate_data_mesg.hpp @@ -0,0 +1,190 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_HEART_RATE_DATA_MESG_HPP) +#define FIT_HSA_HEART_RATE_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaHeartRateDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 Status = 1; + static const FIT_UINT8 HeartRate = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaHeartRateDataMesg(void) : Mesg(Profile::MESG_HSA_HEART_RATE_DATA) + { + } + + HsaHeartRateDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStatusValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns status field + // Comment: Status of measurements in buffer - 0 indicates SEARCHING 1 indicates LOCKED + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetStatus(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set status field + // Comment: Status of measurements in buffer - 0 indicates SEARCHING 1 indicates LOCKED + /////////////////////////////////////////////////////////////////////// + void SetStatus(FIT_UINT8 status) + { + SetFieldUINT8Value(1, status, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of heart_rate + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumHeartRate(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate field + // Units: bpm + // Comment: Beats / min. Blank: 0 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHeartRate(FIT_UINT8 index) const + { + return GetFieldUINT8Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate field + // Units: bpm + // Comment: Beats / min. Blank: 0 + /////////////////////////////////////////////////////////////////////// + void SetHeartRate(FIT_UINT8 index, FIT_UINT8 heartRate) + { + SetFieldUINT8Value(2, heartRate, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_HEART_RATE_DATA_MESG_HPP) diff --git a/fit_hsa_heart_rate_data_mesg_listener.hpp b/fit_hsa_heart_rate_data_mesg_listener.hpp new file mode 100644 index 0000000..808ba7f --- /dev/null +++ b/fit_hsa_heart_rate_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_HEART_RATE_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_HEART_RATE_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_heart_rate_data_mesg.hpp" + +namespace fit +{ + +class HsaHeartRateDataMesgListener +{ +public: + virtual ~HsaHeartRateDataMesgListener() {} + virtual void OnMesg(HsaHeartRateDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_HEART_RATE_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_respiration_data_mesg.hpp b/fit_hsa_respiration_data_mesg.hpp new file mode 100644 index 0000000..c604691 --- /dev/null +++ b/fit_hsa_respiration_data_mesg.hpp @@ -0,0 +1,156 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_RESPIRATION_DATA_MESG_HPP) +#define FIT_HSA_RESPIRATION_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaRespirationDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 RespirationRate = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaRespirationDataMesg(void) : Mesg(Profile::MESG_HSA_RESPIRATION_DATA) + { + } + + HsaRespirationDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of respiration_rate + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumRespirationRate(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRespirationRateValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns respiration_rate field + // Units: breaths/min + // Comment: Breaths / min: [1,100] Invalid: 255 Excess motion: 254 Off wrist: 253 Not available: 252 Blank: 2.4 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRespirationRate(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set respiration_rate field + // Units: breaths/min + // Comment: Breaths / min: [1,100] Invalid: 255 Excess motion: 254 Off wrist: 253 Not available: 252 Blank: 2.4 + /////////////////////////////////////////////////////////////////////// + void SetRespirationRate(FIT_UINT8 index, FIT_FLOAT32 respirationRate) + { + SetFieldFLOAT32Value(1, respirationRate, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_RESPIRATION_DATA_MESG_HPP) diff --git a/fit_hsa_respiration_data_mesg_listener.hpp b/fit_hsa_respiration_data_mesg_listener.hpp new file mode 100644 index 0000000..fbfad7d --- /dev/null +++ b/fit_hsa_respiration_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_RESPIRATION_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_RESPIRATION_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_respiration_data_mesg.hpp" + +namespace fit +{ + +class HsaRespirationDataMesgListener +{ +public: + virtual ~HsaRespirationDataMesgListener() {} + virtual void OnMesg(HsaRespirationDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_RESPIRATION_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_spo2_data_mesg.hpp b/fit_hsa_spo2_data_mesg.hpp new file mode 100644 index 0000000..21bdb8a --- /dev/null +++ b/fit_hsa_spo2_data_mesg.hpp @@ -0,0 +1,198 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_SPO2_DATA_MESG_HPP) +#define FIT_HSA_SPO2_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaSpo2DataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 ReadingSpo2 = 1; + static const FIT_UINT8 Confidence = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaSpo2DataMesg(void) : Mesg(Profile::MESG_HSA_SPO2_DATA) + { + } + + HsaSpo2DataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of reading_spo2 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumReadingSpo2(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reading_spo2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReadingSpo2Valid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reading_spo2 field + // Units: percent + // Comment: SpO2 Reading: [70,100] Blank: 240 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetReadingSpo2(FIT_UINT8 index) const + { + return GetFieldUINT8Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reading_spo2 field + // Units: percent + // Comment: SpO2 Reading: [70,100] Blank: 240 + /////////////////////////////////////////////////////////////////////// + void SetReadingSpo2(FIT_UINT8 index, FIT_UINT8 readingSpo2) + { + SetFieldUINT8Value(1, readingSpo2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of confidence + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumConfidence(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of confidence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConfidenceValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns confidence field + // Comment: SpO2 Confidence: [0,254] + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetConfidence(FIT_UINT8 index) const + { + return GetFieldUINT8Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set confidence field + // Comment: SpO2 Confidence: [0,254] + /////////////////////////////////////////////////////////////////////// + void SetConfidence(FIT_UINT8 index, FIT_UINT8 confidence) + { + SetFieldUINT8Value(2, confidence, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_SPO2_DATA_MESG_HPP) diff --git a/fit_hsa_spo2_data_mesg_listener.hpp b/fit_hsa_spo2_data_mesg_listener.hpp new file mode 100644 index 0000000..40c4991 --- /dev/null +++ b/fit_hsa_spo2_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_SPO2_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_SPO2_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_spo2_data_mesg.hpp" + +namespace fit +{ + +class HsaSpo2DataMesgListener +{ +public: + virtual ~HsaSpo2DataMesgListener() {} + virtual void OnMesg(HsaSpo2DataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_SPO2_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_step_data_mesg.hpp b/fit_hsa_step_data_mesg.hpp new file mode 100644 index 0000000..8c5f5ce --- /dev/null +++ b/fit_hsa_step_data_mesg.hpp @@ -0,0 +1,156 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_STEP_DATA_MESG_HPP) +#define FIT_HSA_STEP_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaStepDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 Steps = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaStepDataMesg(void) : Mesg(Profile::MESG_HSA_STEP_DATA) + { + } + + HsaStepDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds. File start: 0xFFFFFFEF File stop: 0xFFFFFFEE + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds. File start: 0xFFFFFFEF File stop: 0xFFFFFFEE + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of steps + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSteps(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of steps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStepsValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns steps field + // Units: steps + // Comment: Total step sum + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSteps(FIT_UINT8 index) const + { + return GetFieldUINT32Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set steps field + // Units: steps + // Comment: Total step sum + /////////////////////////////////////////////////////////////////////// + void SetSteps(FIT_UINT8 index, FIT_UINT32 steps) + { + SetFieldUINT32Value(1, steps, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_STEP_DATA_MESG_HPP) diff --git a/fit_hsa_step_data_mesg_listener.hpp b/fit_hsa_step_data_mesg_listener.hpp new file mode 100644 index 0000000..9980c60 --- /dev/null +++ b/fit_hsa_step_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_STEP_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_STEP_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_step_data_mesg.hpp" + +namespace fit +{ + +class HsaStepDataMesgListener +{ +public: + virtual ~HsaStepDataMesgListener() {} + virtual void OnMesg(HsaStepDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_STEP_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_stress_data_mesg.hpp b/fit_hsa_stress_data_mesg.hpp new file mode 100644 index 0000000..723b65b --- /dev/null +++ b/fit_hsa_stress_data_mesg.hpp @@ -0,0 +1,154 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_STRESS_DATA_MESG_HPP) +#define FIT_HSA_STRESS_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaStressDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 StressLevel = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaStressDataMesg(void) : Mesg(Profile::MESG_HSA_STRESS_DATA) + { + } + + HsaStressDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of stress_level + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumStressLevel(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stress_level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStressLevelValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stress_level field + // Units: s + // Comment: Stress Level: [0,100] Off wrist: -1 Excess motion: -2 Not enough data: -3 Recovering from exercise: -4 Unidentified: -5 Blank: -16 + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetStressLevel(FIT_UINT8 index) const + { + return GetFieldSINT8Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stress_level field + // Units: s + // Comment: Stress Level: [0,100] Off wrist: -1 Excess motion: -2 Not enough data: -3 Recovering from exercise: -4 Unidentified: -5 Blank: -16 + /////////////////////////////////////////////////////////////////////// + void SetStressLevel(FIT_UINT8 index, FIT_SINT8 stressLevel) + { + SetFieldSINT8Value(1, stressLevel, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_STRESS_DATA_MESG_HPP) diff --git a/fit_hsa_stress_data_mesg_listener.hpp b/fit_hsa_stress_data_mesg_listener.hpp new file mode 100644 index 0000000..6d68481 --- /dev/null +++ b/fit_hsa_stress_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_STRESS_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_STRESS_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_stress_data_mesg.hpp" + +namespace fit +{ + +class HsaStressDataMesgListener +{ +public: + virtual ~HsaStressDataMesgListener() {} + virtual void OnMesg(HsaStressDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_STRESS_DATA_MESG_LISTENER_HPP) diff --git a/fit_hsa_wrist_temperature_data_mesg.hpp b/fit_hsa_wrist_temperature_data_mesg.hpp new file mode 100644 index 0000000..4927ad4 --- /dev/null +++ b/fit_hsa_wrist_temperature_data_mesg.hpp @@ -0,0 +1,156 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_WRIST_TEMPERATURE_DATA_MESG_HPP) +#define FIT_HSA_WRIST_TEMPERATURE_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class HsaWristTemperatureDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ProcessingInterval = 0; + static const FIT_UINT8 Value = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + HsaWristTemperatureDataMesg(void) : Mesg(Profile::MESG_HSA_WRIST_TEMPERATURE_DATA) + { + } + + HsaWristTemperatureDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of processing_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProcessingIntervalValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProcessingInterval(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set processing_interval field + // Units: s + // Comment: Processing interval length in seconds + /////////////////////////////////////////////////////////////////////// + void SetProcessingInterval(FIT_UINT16 processingInterval) + { + SetFieldUINT16Value(0, processingInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of value + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumValue(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsValueValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns value field + // Units: degC + // Comment: Wrist temperature reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetValue(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set value field + // Units: degC + // Comment: Wrist temperature reading + /////////////////////////////////////////////////////////////////////// + void SetValue(FIT_UINT8 index, FIT_FLOAT32 value) + { + SetFieldFLOAT32Value(1, value, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_WRIST_TEMPERATURE_DATA_MESG_HPP) diff --git a/fit_hsa_wrist_temperature_data_mesg_listener.hpp b/fit_hsa_wrist_temperature_data_mesg_listener.hpp new file mode 100644 index 0000000..594bbf5 --- /dev/null +++ b/fit_hsa_wrist_temperature_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_HSA_WRIST_TEMPERATURE_DATA_MESG_LISTENER_HPP) +#define FIT_HSA_WRIST_TEMPERATURE_DATA_MESG_LISTENER_HPP + +#include "fit_hsa_wrist_temperature_data_mesg.hpp" + +namespace fit +{ + +class HsaWristTemperatureDataMesgListener +{ +public: + virtual ~HsaWristTemperatureDataMesgListener() {} + virtual void OnMesg(HsaWristTemperatureDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_HSA_WRIST_TEMPERATURE_DATA_MESG_LISTENER_HPP) diff --git a/fit_jump_mesg.hpp b/fit_jump_mesg.hpp new file mode 100644 index 0000000..475ee21 --- /dev/null +++ b/fit_jump_mesg.hpp @@ -0,0 +1,380 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_JUMP_MESG_HPP) +#define FIT_JUMP_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class JumpMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Distance = 0; + static const FIT_UINT8 Height = 1; + static const FIT_UINT8 Rotations = 2; + static const FIT_UINT8 HangTime = 3; + static const FIT_UINT8 Score = 4; + static const FIT_UINT8 PositionLat = 5; + static const FIT_UINT8 PositionLong = 6; + static const FIT_UINT8 Speed = 7; + static const FIT_UINT8 EnhancedSpeed = 8; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + JumpMesg(void) : Mesg(Profile::MESG_JUMP) + { + } + + JumpMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDistance(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDistance(FIT_FLOAT32 distance) + { + SetFieldFLOAT32Value(0, distance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of height field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeightValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns height field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetHeight(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set height field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetHeight(FIT_FLOAT32 height) + { + SetFieldFLOAT32Value(1, height, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rotations field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRotationsValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rotations field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRotations(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rotations field + /////////////////////////////////////////////////////////////////////// + void SetRotations(FIT_UINT8 rotations) + { + SetFieldUINT8Value(2, rotations, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hang_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHangTimeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hang_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetHangTime(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hang_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetHangTime(FIT_FLOAT32 hangTime) + { + SetFieldFLOAT32Value(3, hangTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScoreValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns score field + // Comment: A score for a jump calculated based on hang time, rotations, and distance. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetScore(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set score field + // Comment: A score for a jump calculated based on hang time, rotations, and distance. + /////////////////////////////////////////////////////////////////////// + void SetScore(FIT_FLOAT32 score) + { + SetFieldFLOAT32Value(4, score, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLatValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLat(void) const + { + return GetFieldSINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLat(FIT_SINT32 positionLat) + { + SetFieldSINT32Value(5, positionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLongValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLong(void) const + { + return GetFieldSINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLong(FIT_SINT32 positionLong) + { + SetFieldSINT32Value(6, positionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeed(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSpeed(FIT_FLOAT32 speed) + { + SetFieldFLOAT32Value(7, speed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedSpeedValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedSpeed(void) const + { + return GetFieldFLOAT32Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetEnhancedSpeed(FIT_FLOAT32 enhancedSpeed) + { + SetFieldFLOAT32Value(8, enhancedSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_JUMP_MESG_HPP) diff --git a/fit_jump_mesg_listener.hpp b/fit_jump_mesg_listener.hpp new file mode 100644 index 0000000..35d26f5 --- /dev/null +++ b/fit_jump_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_JUMP_MESG_LISTENER_HPP) +#define FIT_JUMP_MESG_LISTENER_HPP + +#include "fit_jump_mesg.hpp" + +namespace fit +{ + +class JumpMesgListener +{ +public: + virtual ~JumpMesgListener() {} + virtual void OnMesg(JumpMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_JUMP_MESG_LISTENER_HPP) diff --git a/fit_lap_mesg.hpp b/fit_lap_mesg.hpp new file mode 100644 index 0000000..ff7c03a --- /dev/null +++ b/fit_lap_mesg.hpp @@ -0,0 +1,4583 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_LAP_MESG_HPP) +#define FIT_LAP_MESG_HPP + +#include "fit_mesg.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class LapMesg : public Mesg, public MesgWithEvent +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Event = 0; + static const FIT_UINT8 EventType = 1; + static const FIT_UINT8 StartTime = 2; + static const FIT_UINT8 StartPositionLat = 3; + static const FIT_UINT8 StartPositionLong = 4; + static const FIT_UINT8 EndPositionLat = 5; + static const FIT_UINT8 EndPositionLong = 6; + static const FIT_UINT8 TotalElapsedTime = 7; + static const FIT_UINT8 TotalTimerTime = 8; + static const FIT_UINT8 TotalDistance = 9; + static const FIT_UINT8 TotalCycles = 10; + static const FIT_UINT8 TotalCalories = 11; + static const FIT_UINT8 TotalFatCalories = 12; + static const FIT_UINT8 AvgSpeed = 13; + static const FIT_UINT8 MaxSpeed = 14; + static const FIT_UINT8 AvgHeartRate = 15; + static const FIT_UINT8 MaxHeartRate = 16; + static const FIT_UINT8 AvgCadence = 17; + static const FIT_UINT8 MaxCadence = 18; + static const FIT_UINT8 AvgPower = 19; + static const FIT_UINT8 MaxPower = 20; + static const FIT_UINT8 TotalAscent = 21; + static const FIT_UINT8 TotalDescent = 22; + static const FIT_UINT8 Intensity = 23; + static const FIT_UINT8 LapTrigger = 24; + static const FIT_UINT8 Sport = 25; + static const FIT_UINT8 EventGroup = 26; + static const FIT_UINT8 NumLengths = 32; + static const FIT_UINT8 NormalizedPower = 33; + static const FIT_UINT8 LeftRightBalance = 34; + static const FIT_UINT8 FirstLengthIndex = 35; + static const FIT_UINT8 AvgStrokeDistance = 37; + static const FIT_UINT8 SwimStroke = 38; + static const FIT_UINT8 SubSport = 39; + static const FIT_UINT8 NumActiveLengths = 40; + static const FIT_UINT8 TotalWork = 41; + static const FIT_UINT8 AvgAltitude = 42; + static const FIT_UINT8 MaxAltitude = 43; + static const FIT_UINT8 GpsAccuracy = 44; + static const FIT_UINT8 AvgGrade = 45; + static const FIT_UINT8 AvgPosGrade = 46; + static const FIT_UINT8 AvgNegGrade = 47; + static const FIT_UINT8 MaxPosGrade = 48; + static const FIT_UINT8 MaxNegGrade = 49; + static const FIT_UINT8 AvgTemperature = 50; + static const FIT_UINT8 MaxTemperature = 51; + static const FIT_UINT8 TotalMovingTime = 52; + static const FIT_UINT8 AvgPosVerticalSpeed = 53; + static const FIT_UINT8 AvgNegVerticalSpeed = 54; + static const FIT_UINT8 MaxPosVerticalSpeed = 55; + static const FIT_UINT8 MaxNegVerticalSpeed = 56; + static const FIT_UINT8 TimeInHrZone = 57; + static const FIT_UINT8 TimeInSpeedZone = 58; + static const FIT_UINT8 TimeInCadenceZone = 59; + static const FIT_UINT8 TimeInPowerZone = 60; + static const FIT_UINT8 RepetitionNum = 61; + static const FIT_UINT8 MinAltitude = 62; + static const FIT_UINT8 MinHeartRate = 63; + static const FIT_UINT8 WktStepIndex = 71; + static const FIT_UINT8 OpponentScore = 74; + static const FIT_UINT8 StrokeCount = 75; + static const FIT_UINT8 ZoneCount = 76; + static const FIT_UINT8 AvgVerticalOscillation = 77; + static const FIT_UINT8 AvgStanceTimePercent = 78; + static const FIT_UINT8 AvgStanceTime = 79; + static const FIT_UINT8 AvgFractionalCadence = 80; + static const FIT_UINT8 MaxFractionalCadence = 81; + static const FIT_UINT8 TotalFractionalCycles = 82; + static const FIT_UINT8 PlayerScore = 83; + static const FIT_UINT8 AvgTotalHemoglobinConc = 84; + static const FIT_UINT8 MinTotalHemoglobinConc = 85; + static const FIT_UINT8 MaxTotalHemoglobinConc = 86; + static const FIT_UINT8 AvgSaturatedHemoglobinPercent = 87; + static const FIT_UINT8 MinSaturatedHemoglobinPercent = 88; + static const FIT_UINT8 MaxSaturatedHemoglobinPercent = 89; + static const FIT_UINT8 AvgLeftTorqueEffectiveness = 91; + static const FIT_UINT8 AvgRightTorqueEffectiveness = 92; + static const FIT_UINT8 AvgLeftPedalSmoothness = 93; + static const FIT_UINT8 AvgRightPedalSmoothness = 94; + static const FIT_UINT8 AvgCombinedPedalSmoothness = 95; + static const FIT_UINT8 TimeStanding = 98; + static const FIT_UINT8 StandCount = 99; + static const FIT_UINT8 AvgLeftPco = 100; + static const FIT_UINT8 AvgRightPco = 101; + static const FIT_UINT8 AvgLeftPowerPhase = 102; + static const FIT_UINT8 AvgLeftPowerPhasePeak = 103; + static const FIT_UINT8 AvgRightPowerPhase = 104; + static const FIT_UINT8 AvgRightPowerPhasePeak = 105; + static const FIT_UINT8 AvgPowerPosition = 106; + static const FIT_UINT8 MaxPowerPosition = 107; + static const FIT_UINT8 AvgCadencePosition = 108; + static const FIT_UINT8 MaxCadencePosition = 109; + static const FIT_UINT8 EnhancedAvgSpeed = 110; + static const FIT_UINT8 EnhancedMaxSpeed = 111; + static const FIT_UINT8 EnhancedAvgAltitude = 112; + static const FIT_UINT8 EnhancedMinAltitude = 113; + static const FIT_UINT8 EnhancedMaxAltitude = 114; + static const FIT_UINT8 AvgLevMotorPower = 115; + static const FIT_UINT8 MaxLevMotorPower = 116; + static const FIT_UINT8 LevBatteryConsumption = 117; + static const FIT_UINT8 AvgVerticalRatio = 118; + static const FIT_UINT8 AvgStanceTimeBalance = 119; + static const FIT_UINT8 AvgStepLength = 120; + static const FIT_UINT8 AvgVam = 121; + static const FIT_UINT8 AvgDepth = 122; + static const FIT_UINT8 MaxDepth = 123; + static const FIT_UINT8 MinTemperature = 124; + static const FIT_UINT8 EnhancedAvgRespirationRate = 136; + static const FIT_UINT8 EnhancedMaxRespirationRate = 137; + static const FIT_UINT8 AvgRespirationRate = 147; + static const FIT_UINT8 MaxRespirationRate = 148; + static const FIT_UINT8 TotalGrit = 149; + static const FIT_UINT8 TotalFlow = 150; + static const FIT_UINT8 JumpCount = 151; + static const FIT_UINT8 AvgGrit = 153; + static const FIT_UINT8 AvgFlow = 154; + static const FIT_UINT8 TotalFractionalAscent = 156; + static const FIT_UINT8 TotalFractionalDescent = 157; + static const FIT_UINT8 AvgCoreTemperature = 158; + static const FIT_UINT8 MinCoreTemperature = 159; + static const FIT_UINT8 MaxCoreTemperature = 160; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + LapMesg(void) : Mesg(Profile::MESG_LAP) + { + } + + LapMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT GetEvent(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event field + /////////////////////////////////////////////////////////////////////// + void SetEvent(FIT_EVENT event) + { + SetFieldENUMValue(0, event, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_type field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT_TYPE GetEventType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_type field + /////////////////////////////////////////////////////////////////////// + void SetEventType(FIT_EVENT_TYPE eventType) + { + SetFieldENUMValue(1, eventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTime(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_time field + /////////////////////////////////////////////////////////////////////// + void SetStartTime(FIT_DATE_TIME startTime) + { + SetFieldUINT32Value(2, startTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLatValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLat(void) const + { + return GetFieldSINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLat(FIT_SINT32 startPositionLat) + { + SetFieldSINT32Value(3, startPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLongValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLong(void) const + { + return GetFieldSINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLong(FIT_SINT32 startPositionLong) + { + SetFieldSINT32Value(4, startPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLatValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLat(void) const + { + return GetFieldSINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLat(FIT_SINT32 endPositionLat) + { + SetFieldSINT32Value(5, endPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLongValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLong(void) const + { + return GetFieldSINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLong(FIT_SINT32 endPositionLong) + { + SetFieldSINT32Value(6, endPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_elapsed_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalElapsedTimeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_elapsed_time field + // Units: s + // Comment: Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalElapsedTime(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_elapsed_time field + // Units: s + // Comment: Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + void SetTotalElapsedTime(FIT_FLOAT32 totalElapsedTime) + { + SetFieldFLOAT32Value(7, totalElapsedTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + // Comment: Timer Time (excludes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + // Comment: Timer Time (excludes pauses) + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(8, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDistanceValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalDistance(void) const + { + return GetFieldFLOAT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDistance(FIT_FLOAT32 totalDistance) + { + SetFieldFLOAT32Value(9, totalDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCyclesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalCycles(void) const + { + return GetFieldUINT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalCycles(FIT_UINT32 totalCycles) + { + SetFieldUINT32Value(10, totalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_strides field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalStridesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns total_strides field + // Units: strides + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalStrides(void) const + { + return GetFieldUINT32Value(10, 0, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_strides field + // Units: strides + /////////////////////////////////////////////////////////////////////// + void SetTotalStrides(FIT_UINT32 totalStrides) + { + SetFieldUINT32Value(10, totalStrides, 0, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_strokes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalStrokesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalStrokes(void) const + { + return GetFieldUINT32Value(10, 0, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + void SetTotalStrokes(FIT_UINT32 totalStrokes) + { + SetFieldUINT32Value(10, totalStrokes, 0, (FIT_UINT16) Profile::LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCaloriesValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalCalories(void) const + { + return GetFieldUINT16Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalCalories(FIT_UINT16 totalCalories) + { + SetFieldUINT16Value(11, totalCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fat_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFatCaloriesValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fat_calories field + // Units: kcal + // Comment: If New Leaf + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalFatCalories(void) const + { + return GetFieldUINT16Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fat_calories field + // Units: kcal + // Comment: If New Leaf + /////////////////////////////////////////////////////////////////////// + void SetTotalFatCalories(FIT_UINT16 totalFatCalories) + { + SetFieldUINT16Value(12, totalFatCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(13, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSpeedValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSpeed(void) const + { + return GetFieldFLOAT32Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxSpeed(FIT_FLOAT32 maxSpeed) + { + SetFieldFLOAT32Value(14, maxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgHeartRateValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgHeartRate(void) const + { + return GetFieldUINT8Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetAvgHeartRate(FIT_UINT8 avgHeartRate) + { + SetFieldUINT8Value(15, avgHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxHeartRateValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxHeartRate(void) const + { + return GetFieldUINT8Value(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMaxHeartRate(FIT_UINT8 maxHeartRate) + { + SetFieldUINT8Value(16, maxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCadenceValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_cadence field + // Units: rpm + // Comment: total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgCadence(void) const + { + return GetFieldUINT8Value(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_cadence field + // Units: rpm + // Comment: total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + void SetAvgCadence(FIT_UINT8 avgCadence) + { + SetFieldUINT8Value(17, avgCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_running_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRunningCadenceValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::LAP_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::LAP_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns avg_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgRunningCadence(void) const + { + return GetFieldUINT8Value(17, 0, (FIT_UINT16) Profile::LAP_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + void SetAvgRunningCadence(FIT_UINT8 avgRunningCadence) + { + SetFieldUINT8Value(17, avgRunningCadence, 0, (FIT_UINT16) Profile::LAP_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCadenceValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxCadence(void) const + { + return GetFieldUINT8Value(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetMaxCadence(FIT_UINT8 maxCadence) + { + SetFieldUINT8Value(18, maxCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_running_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxRunningCadenceValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::LAP_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::LAP_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns max_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxRunningCadence(void) const + { + return GetFieldUINT8Value(18, 0, (FIT_UINT16) Profile::LAP_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + void SetMaxRunningCadence(FIT_UINT8 maxRunningCadence) + { + SetFieldUINT8Value(18, maxRunningCadence, 0, (FIT_UINT16) Profile::LAP_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPowerValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_power field + // Units: watts + // Comment: total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgPower(void) const + { + return GetFieldUINT16Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_power field + // Units: watts + // Comment: total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + void SetAvgPower(FIT_UINT16 avgPower) + { + SetFieldUINT16Value(19, avgPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPowerValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPower(void) const + { + return GetFieldUINT16Value(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetMaxPower(FIT_UINT16 maxPower) + { + SetFieldUINT16Value(20, maxPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalAscentValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalAscent(void) const + { + return GetFieldUINT16Value(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalAscent(FIT_UINT16 totalAscent) + { + SetFieldUINT16Value(21, totalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDescentValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalDescent(void) const + { + return GetFieldUINT16Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDescent(FIT_UINT16 totalDescent) + { + SetFieldUINT16Value(22, totalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of intensity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIntensityValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns intensity field + /////////////////////////////////////////////////////////////////////// + FIT_INTENSITY GetIntensity(void) const + { + return GetFieldENUMValue(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set intensity field + /////////////////////////////////////////////////////////////////////// + void SetIntensity(FIT_INTENSITY intensity) + { + SetFieldENUMValue(23, intensity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of lap_trigger field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLapTriggerValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns lap_trigger field + /////////////////////////////////////////////////////////////////////// + FIT_LAP_TRIGGER GetLapTrigger(void) const + { + return GetFieldENUMValue(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set lap_trigger field + /////////////////////////////////////////////////////////////////////// + void SetLapTrigger(FIT_LAP_TRIGGER lapTrigger) + { + SetFieldENUMValue(24, lapTrigger, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(25, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_group field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventGroupValid() const + { + const Field* field = GetField(26); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_group field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventGroup(void) const + { + return GetFieldUINT8Value(26, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_group field + /////////////////////////////////////////////////////////////////////// + void SetEventGroup(FIT_UINT8 eventGroup) + { + SetFieldUINT8Value(26, eventGroup, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_lengths field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumLengthsValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_lengths field + // Units: lengths + // Comment: # of lengths of swim pool + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumLengths(void) const + { + return GetFieldUINT16Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_lengths field + // Units: lengths + // Comment: # of lengths of swim pool + /////////////////////////////////////////////////////////////////////// + void SetNumLengths(FIT_UINT16 numLengths) + { + SetFieldUINT16Value(32, numLengths, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of normalized_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNormalizedPowerValid() const + { + const Field* field = GetField(33); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns normalized_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNormalizedPower(void) const + { + return GetFieldUINT16Value(33, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set normalized_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetNormalizedPower(FIT_UINT16 normalizedPower) + { + SetFieldUINT16Value(33, normalizedPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_right_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftRightBalanceValid() const + { + const Field* field = GetField(34); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_right_balance field + /////////////////////////////////////////////////////////////////////// + FIT_LEFT_RIGHT_BALANCE_100 GetLeftRightBalance(void) const + { + return GetFieldUINT16Value(34, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_right_balance field + /////////////////////////////////////////////////////////////////////// + void SetLeftRightBalance(FIT_LEFT_RIGHT_BALANCE_100 leftRightBalance) + { + SetFieldUINT16Value(34, leftRightBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of first_length_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFirstLengthIndexValid() const + { + const Field* field = GetField(35); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns first_length_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetFirstLengthIndex(void) const + { + return GetFieldUINT16Value(35, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set first_length_index field + /////////////////////////////////////////////////////////////////////// + void SetFirstLengthIndex(FIT_UINT16 firstLengthIndex) + { + SetFieldUINT16Value(35, firstLengthIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stroke_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStrokeDistanceValid() const + { + const Field* field = GetField(37); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stroke_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStrokeDistance(void) const + { + return GetFieldFLOAT32Value(37, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stroke_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAvgStrokeDistance(FIT_FLOAT32 avgStrokeDistance) + { + SetFieldFLOAT32Value(37, avgStrokeDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swim_stroke field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwimStrokeValid() const + { + const Field* field = GetField(38); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swim_stroke field + /////////////////////////////////////////////////////////////////////// + FIT_SWIM_STROKE GetSwimStroke(void) const + { + return GetFieldENUMValue(38, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swim_stroke field + /////////////////////////////////////////////////////////////////////// + void SetSwimStroke(FIT_SWIM_STROKE swimStroke) + { + SetFieldENUMValue(38, swimStroke, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(39); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(39, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(39, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_active_lengths field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumActiveLengthsValid() const + { + const Field* field = GetField(40); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_active_lengths field + // Units: lengths + // Comment: # of active lengths of swim pool + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumActiveLengths(void) const + { + return GetFieldUINT16Value(40, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_active_lengths field + // Units: lengths + // Comment: # of active lengths of swim pool + /////////////////////////////////////////////////////////////////////// + void SetNumActiveLengths(FIT_UINT16 numActiveLengths) + { + SetFieldUINT16Value(40, numActiveLengths, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_work field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalWorkValid() const + { + const Field* field = GetField(41); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_work field + // Units: J + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalWork(void) const + { + return GetFieldUINT32Value(41, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_work field + // Units: J + /////////////////////////////////////////////////////////////////////// + void SetTotalWork(FIT_UINT32 totalWork) + { + SetFieldUINT32Value(41, totalWork, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgAltitudeValid() const + { + const Field* field = GetField(42); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgAltitude(void) const + { + return GetFieldFLOAT32Value(42, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAvgAltitude(FIT_FLOAT32 avgAltitude) + { + SetFieldFLOAT32Value(42, avgAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxAltitudeValid() const + { + const Field* field = GetField(43); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxAltitude(void) const + { + return GetFieldFLOAT32Value(43, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetMaxAltitude(FIT_FLOAT32 maxAltitude) + { + SetFieldFLOAT32Value(43, maxAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gps_accuracy field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGpsAccuracyValid() const + { + const Field* field = GetField(44); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGpsAccuracy(void) const + { + return GetFieldUINT8Value(44, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetGpsAccuracy(FIT_UINT8 gpsAccuracy) + { + SetFieldUINT8Value(44, gpsAccuracy, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgGradeValid() const + { + const Field* field = GetField(45); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgGrade(void) const + { + return GetFieldFLOAT32Value(45, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgGrade(FIT_FLOAT32 avgGrade) + { + SetFieldFLOAT32Value(45, avgGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pos_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPosGradeValid() const + { + const Field* field = GetField(46); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPosGrade(void) const + { + return GetFieldFLOAT32Value(46, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgPosGrade(FIT_FLOAT32 avgPosGrade) + { + SetFieldFLOAT32Value(46, avgPosGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_neg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgNegGradeValid() const + { + const Field* field = GetField(47); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgNegGrade(void) const + { + return GetFieldFLOAT32Value(47, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgNegGrade(FIT_FLOAT32 avgNegGrade) + { + SetFieldFLOAT32Value(47, avgNegGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_pos_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPosGradeValid() const + { + const Field* field = GetField(48); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxPosGrade(void) const + { + return GetFieldFLOAT32Value(48, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetMaxPosGrade(FIT_FLOAT32 maxPosGrade) + { + SetFieldFLOAT32Value(48, maxPosGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_neg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxNegGradeValid() const + { + const Field* field = GetField(49); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxNegGrade(void) const + { + return GetFieldFLOAT32Value(49, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetMaxNegGrade(FIT_FLOAT32 maxNegGrade) + { + SetFieldFLOAT32Value(49, maxNegGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgTemperatureValid() const + { + const Field* field = GetField(50); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgTemperature(void) const + { + return GetFieldSINT8Value(50, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetAvgTemperature(FIT_SINT8 avgTemperature) + { + SetFieldSINT8Value(50, avgTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxTemperatureValid() const + { + const Field* field = GetField(51); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetMaxTemperature(void) const + { + return GetFieldSINT8Value(51, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMaxTemperature(FIT_SINT8 maxTemperature) + { + SetFieldSINT8Value(51, maxTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_moving_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalMovingTimeValid() const + { + const Field* field = GetField(52); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalMovingTime(void) const + { + return GetFieldFLOAT32Value(52, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalMovingTime(FIT_FLOAT32 totalMovingTime) + { + SetFieldFLOAT32Value(52, totalMovingTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pos_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPosVerticalSpeedValid() const + { + const Field* field = GetField(53); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPosVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(53, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgPosVerticalSpeed(FIT_FLOAT32 avgPosVerticalSpeed) + { + SetFieldFLOAT32Value(53, avgPosVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_neg_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgNegVerticalSpeedValid() const + { + const Field* field = GetField(54); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgNegVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(54, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgNegVerticalSpeed(FIT_FLOAT32 avgNegVerticalSpeed) + { + SetFieldFLOAT32Value(54, avgNegVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_pos_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPosVerticalSpeedValid() const + { + const Field* field = GetField(55); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxPosVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(55, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxPosVerticalSpeed(FIT_FLOAT32 maxPosVerticalSpeed) + { + SetFieldFLOAT32Value(55, maxPosVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_neg_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxNegVerticalSpeedValid() const + { + const Field* field = GetField(56); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxNegVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(56, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxNegVerticalSpeed(FIT_FLOAT32 maxNegVerticalSpeed) + { + SetFieldFLOAT32Value(56, maxNegVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_hr_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInHrZone(void) const + { + return GetFieldNumValues(57, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_hr_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInHrZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(57); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInHrZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(57, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInHrZone(FIT_UINT8 index, FIT_FLOAT32 timeInHrZone) + { + SetFieldFLOAT32Value(57, timeInHrZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_speed_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInSpeedZone(void) const + { + return GetFieldNumValues(58, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_speed_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInSpeedZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(58); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInSpeedZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(58, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInSpeedZone(FIT_UINT8 index, FIT_FLOAT32 timeInSpeedZone) + { + SetFieldFLOAT32Value(58, timeInSpeedZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_cadence_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInCadenceZone(void) const + { + return GetFieldNumValues(59, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_cadence_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInCadenceZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(59); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInCadenceZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(59, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInCadenceZone(FIT_UINT8 index, FIT_FLOAT32 timeInCadenceZone) + { + SetFieldFLOAT32Value(59, timeInCadenceZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_power_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInPowerZone(void) const + { + return GetFieldNumValues(60, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_power_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInPowerZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(60); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInPowerZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(60, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInPowerZone(FIT_UINT8 index, FIT_FLOAT32 timeInPowerZone) + { + SetFieldFLOAT32Value(60, timeInPowerZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repetition_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepetitionNumValid() const + { + const Field* field = GetField(61); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repetition_num field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRepetitionNum(void) const + { + return GetFieldUINT16Value(61, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repetition_num field + /////////////////////////////////////////////////////////////////////// + void SetRepetitionNum(FIT_UINT16 repetitionNum) + { + SetFieldUINT16Value(61, repetitionNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinAltitudeValid() const + { + const Field* field = GetField(62); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinAltitude(void) const + { + return GetFieldFLOAT32Value(62, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetMinAltitude(FIT_FLOAT32 minAltitude) + { + SetFieldFLOAT32Value(62, minAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinHeartRateValid() const + { + const Field* field = GetField(63); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMinHeartRate(void) const + { + return GetFieldUINT8Value(63, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMinHeartRate(FIT_UINT8 minHeartRate) + { + SetFieldUINT8Value(63, minHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_step_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktStepIndexValid() const + { + const Field* field = GetField(71); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_step_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetWktStepIndex(void) const + { + return GetFieldUINT16Value(71, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_step_index field + /////////////////////////////////////////////////////////////////////// + void SetWktStepIndex(FIT_MESSAGE_INDEX wktStepIndex) + { + SetFieldUINT16Value(71, wktStepIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of opponent_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOpponentScoreValid() const + { + const Field* field = GetField(74); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns opponent_score field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetOpponentScore(void) const + { + return GetFieldUINT16Value(74, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set opponent_score field + /////////////////////////////////////////////////////////////////////// + void SetOpponentScore(FIT_UINT16 opponentScore) + { + SetFieldUINT16Value(74, opponentScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of stroke_count + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumStrokeCount(void) const + { + return GetFieldNumValues(75, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stroke_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStrokeCountValid(FIT_UINT8 index) const + { + const Field* field = GetField(75); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stroke_count field + // Units: counts + // Comment: stroke_type enum used as the index + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStrokeCount(FIT_UINT8 index) const + { + return GetFieldUINT16Value(75, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stroke_count field + // Units: counts + // Comment: stroke_type enum used as the index + /////////////////////////////////////////////////////////////////////// + void SetStrokeCount(FIT_UINT8 index, FIT_UINT16 strokeCount) + { + SetFieldUINT16Value(75, strokeCount, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of zone_count + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumZoneCount(void) const + { + return GetFieldNumValues(76, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of zone_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsZoneCountValid(FIT_UINT8 index) const + { + const Field* field = GetField(76); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns zone_count field + // Units: counts + // Comment: zone number used as the index + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetZoneCount(FIT_UINT8 index) const + { + return GetFieldUINT16Value(76, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set zone_count field + // Units: counts + // Comment: zone number used as the index + /////////////////////////////////////////////////////////////////////// + void SetZoneCount(FIT_UINT8 index, FIT_UINT16 zoneCount) + { + SetFieldUINT16Value(76, zoneCount, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vertical_oscillation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVerticalOscillationValid() const + { + const Field* field = GetField(77); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vertical_oscillation field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVerticalOscillation(void) const + { + return GetFieldFLOAT32Value(77, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vertical_oscillation field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetAvgVerticalOscillation(FIT_FLOAT32 avgVerticalOscillation) + { + SetFieldFLOAT32Value(77, avgVerticalOscillation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stance_time_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStanceTimePercentValid() const + { + const Field* field = GetField(78); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stance_time_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStanceTimePercent(void) const + { + return GetFieldFLOAT32Value(78, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stance_time_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgStanceTimePercent(FIT_FLOAT32 avgStanceTimePercent) + { + SetFieldFLOAT32Value(78, avgStanceTimePercent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stance_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStanceTimeValid() const + { + const Field* field = GetField(79); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stance_time field + // Units: ms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStanceTime(void) const + { + return GetFieldFLOAT32Value(79, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stance_time field + // Units: ms + /////////////////////////////////////////////////////////////////////// + void SetAvgStanceTime(FIT_FLOAT32 avgStanceTime) + { + SetFieldFLOAT32Value(79, avgStanceTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgFractionalCadenceValid() const + { + const Field* field = GetField(80); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_fractional_cadence field + // Units: rpm + // Comment: fractional part of the avg_cadence + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgFractionalCadence(void) const + { + return GetFieldFLOAT32Value(80, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_fractional_cadence field + // Units: rpm + // Comment: fractional part of the avg_cadence + /////////////////////////////////////////////////////////////////////// + void SetAvgFractionalCadence(FIT_FLOAT32 avgFractionalCadence) + { + SetFieldFLOAT32Value(80, avgFractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxFractionalCadenceValid() const + { + const Field* field = GetField(81); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_fractional_cadence field + // Units: rpm + // Comment: fractional part of the max_cadence + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxFractionalCadence(void) const + { + return GetFieldFLOAT32Value(81, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_fractional_cadence field + // Units: rpm + // Comment: fractional part of the max_cadence + /////////////////////////////////////////////////////////////////////// + void SetMaxFractionalCadence(FIT_FLOAT32 maxFractionalCadence) + { + SetFieldFLOAT32Value(81, maxFractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalCyclesValid() const + { + const Field* field = GetField(82); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_cycles field + // Units: cycles + // Comment: fractional part of the total_cycles + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalCycles(void) const + { + return GetFieldFLOAT32Value(82, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_cycles field + // Units: cycles + // Comment: fractional part of the total_cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalCycles(FIT_FLOAT32 totalFractionalCycles) + { + SetFieldFLOAT32Value(82, totalFractionalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of player_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPlayerScoreValid() const + { + const Field* field = GetField(83); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns player_score field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPlayerScore(void) const + { + return GetFieldUINT16Value(83, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set player_score field + /////////////////////////////////////////////////////////////////////// + void SetPlayerScore(FIT_UINT16 playerScore) + { + SetFieldUINT16Value(83, playerScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_total_hemoglobin_conc + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgTotalHemoglobinConc(void) const + { + return GetFieldNumValues(84, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgTotalHemoglobinConcValid(FIT_UINT8 index) const + { + const Field* field = GetField(84); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_total_hemoglobin_conc field + // Units: g/dL + // Comment: Avg saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgTotalHemoglobinConc(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(84, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_total_hemoglobin_conc field + // Units: g/dL + // Comment: Avg saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetAvgTotalHemoglobinConc(FIT_UINT8 index, FIT_FLOAT32 avgTotalHemoglobinConc) + { + SetFieldFLOAT32Value(84, avgTotalHemoglobinConc, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of min_total_hemoglobin_conc + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMinTotalHemoglobinConc(void) const + { + return GetFieldNumValues(85, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinTotalHemoglobinConcValid(FIT_UINT8 index) const + { + const Field* field = GetField(85); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_total_hemoglobin_conc field + // Units: g/dL + // Comment: Min saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinTotalHemoglobinConc(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(85, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_total_hemoglobin_conc field + // Units: g/dL + // Comment: Min saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetMinTotalHemoglobinConc(FIT_UINT8 index, FIT_FLOAT32 minTotalHemoglobinConc) + { + SetFieldFLOAT32Value(85, minTotalHemoglobinConc, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_total_hemoglobin_conc + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxTotalHemoglobinConc(void) const + { + return GetFieldNumValues(86, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxTotalHemoglobinConcValid(FIT_UINT8 index) const + { + const Field* field = GetField(86); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_total_hemoglobin_conc field + // Units: g/dL + // Comment: Max saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxTotalHemoglobinConc(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(86, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_total_hemoglobin_conc field + // Units: g/dL + // Comment: Max saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetMaxTotalHemoglobinConc(FIT_UINT8 index, FIT_FLOAT32 maxTotalHemoglobinConc) + { + SetFieldFLOAT32Value(86, maxTotalHemoglobinConc, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_saturated_hemoglobin_percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgSaturatedHemoglobinPercent(void) const + { + return GetFieldNumValues(87, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSaturatedHemoglobinPercentValid(FIT_UINT8 index) const + { + const Field* field = GetField(87); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_saturated_hemoglobin_percent field + // Units: % + // Comment: Avg percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSaturatedHemoglobinPercent(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(87, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_saturated_hemoglobin_percent field + // Units: % + // Comment: Avg percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetAvgSaturatedHemoglobinPercent(FIT_UINT8 index, FIT_FLOAT32 avgSaturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(87, avgSaturatedHemoglobinPercent, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of min_saturated_hemoglobin_percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMinSaturatedHemoglobinPercent(void) const + { + return GetFieldNumValues(88, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinSaturatedHemoglobinPercentValid(FIT_UINT8 index) const + { + const Field* field = GetField(88); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_saturated_hemoglobin_percent field + // Units: % + // Comment: Min percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinSaturatedHemoglobinPercent(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(88, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_saturated_hemoglobin_percent field + // Units: % + // Comment: Min percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetMinSaturatedHemoglobinPercent(FIT_UINT8 index, FIT_FLOAT32 minSaturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(88, minSaturatedHemoglobinPercent, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_saturated_hemoglobin_percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxSaturatedHemoglobinPercent(void) const + { + return GetFieldNumValues(89, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSaturatedHemoglobinPercentValid(FIT_UINT8 index) const + { + const Field* field = GetField(89); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_saturated_hemoglobin_percent field + // Units: % + // Comment: Max percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSaturatedHemoglobinPercent(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(89, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_saturated_hemoglobin_percent field + // Units: % + // Comment: Max percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetMaxSaturatedHemoglobinPercent(FIT_UINT8 index, FIT_FLOAT32 maxSaturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(89, maxSaturatedHemoglobinPercent, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftTorqueEffectivenessValid() const + { + const Field* field = GetField(91); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(91, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftTorqueEffectiveness(FIT_FLOAT32 avgLeftTorqueEffectiveness) + { + SetFieldFLOAT32Value(91, avgLeftTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightTorqueEffectivenessValid() const + { + const Field* field = GetField(92); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(92, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgRightTorqueEffectiveness(FIT_FLOAT32 avgRightTorqueEffectiveness) + { + SetFieldFLOAT32Value(92, avgRightTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPedalSmoothnessValid() const + { + const Field* field = GetField(93); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(93, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPedalSmoothness(FIT_FLOAT32 avgLeftPedalSmoothness) + { + SetFieldFLOAT32Value(93, avgLeftPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPedalSmoothnessValid() const + { + const Field* field = GetField(94); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(94, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPedalSmoothness(FIT_FLOAT32 avgRightPedalSmoothness) + { + SetFieldFLOAT32Value(94, avgRightPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_combined_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCombinedPedalSmoothnessValid() const + { + const Field* field = GetField(95); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgCombinedPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(95, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgCombinedPedalSmoothness(FIT_FLOAT32 avgCombinedPedalSmoothness) + { + SetFieldFLOAT32Value(95, avgCombinedPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_standing field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeStandingValid() const + { + const Field* field = GetField(98); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_standing field + // Units: s + // Comment: Total time spent in the standing position + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeStanding(void) const + { + return GetFieldFLOAT32Value(98, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_standing field + // Units: s + // Comment: Total time spent in the standing position + /////////////////////////////////////////////////////////////////////// + void SetTimeStanding(FIT_FLOAT32 timeStanding) + { + SetFieldFLOAT32Value(98, timeStanding, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stand_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStandCountValid() const + { + const Field* field = GetField(99); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stand_count field + // Comment: Number of transitions to the standing state + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStandCount(void) const + { + return GetFieldUINT16Value(99, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stand_count field + // Comment: Number of transitions to the standing state + /////////////////////////////////////////////////////////////////////// + void SetStandCount(FIT_UINT16 standCount) + { + SetFieldUINT16Value(99, standCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPcoValid() const + { + const Field* field = GetField(100); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_pco field + // Units: mm + // Comment: Average left platform center offset + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgLeftPco(void) const + { + return GetFieldSINT8Value(100, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_pco field + // Units: mm + // Comment: Average left platform center offset + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPco(FIT_SINT8 avgLeftPco) + { + SetFieldSINT8Value(100, avgLeftPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPcoValid() const + { + const Field* field = GetField(101); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_pco field + // Units: mm + // Comment: Average right platform center offset + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgRightPco(void) const + { + return GetFieldSINT8Value(101, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_pco field + // Units: mm + // Comment: Average right platform center offset + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPco(FIT_SINT8 avgRightPco) + { + SetFieldSINT8Value(101, avgRightPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_left_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgLeftPowerPhase(void) const + { + return GetFieldNumValues(102, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(102); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_power_phase field + // Units: degrees + // Comment: Average left power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(102, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_power_phase field + // Units: degrees + // Comment: Average left power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPowerPhase(FIT_UINT8 index, FIT_FLOAT32 avgLeftPowerPhase) + { + SetFieldFLOAT32Value(102, avgLeftPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_left_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgLeftPowerPhasePeak(void) const + { + return GetFieldNumValues(103, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(103); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_power_phase_peak field + // Units: degrees + // Comment: Average left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(103, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_power_phase_peak field + // Units: degrees + // Comment: Average left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 avgLeftPowerPhasePeak) + { + SetFieldFLOAT32Value(103, avgLeftPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_right_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgRightPowerPhase(void) const + { + return GetFieldNumValues(104, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(104); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_power_phase field + // Units: degrees + // Comment: Average right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(104, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_power_phase field + // Units: degrees + // Comment: Average right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPowerPhase(FIT_UINT8 index, FIT_FLOAT32 avgRightPowerPhase) + { + SetFieldFLOAT32Value(104, avgRightPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_right_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgRightPowerPhasePeak(void) const + { + return GetFieldNumValues(105, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(105); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_power_phase_peak field + // Units: degrees + // Comment: Average right power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(105, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_power_phase_peak field + // Units: degrees + // Comment: Average right power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 avgRightPowerPhasePeak) + { + SetFieldFLOAT32Value(105, avgRightPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_power_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgPowerPosition(void) const + { + return GetFieldNumValues(106, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_power_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPowerPositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(106); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_power_position field + // Units: watts + // Comment: Average power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgPowerPosition(FIT_UINT8 index) const + { + return GetFieldUINT16Value(106, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_power_position field + // Units: watts + // Comment: Average power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgPowerPosition(FIT_UINT8 index, FIT_UINT16 avgPowerPosition) + { + SetFieldUINT16Value(106, avgPowerPosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_power_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxPowerPosition(void) const + { + return GetFieldNumValues(107, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_power_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPowerPositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(107); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_power_position field + // Units: watts + // Comment: Maximum power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPowerPosition(FIT_UINT8 index) const + { + return GetFieldUINT16Value(107, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_power_position field + // Units: watts + // Comment: Maximum power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetMaxPowerPosition(FIT_UINT8 index, FIT_UINT16 maxPowerPosition) + { + SetFieldUINT16Value(107, maxPowerPosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_cadence_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgCadencePosition(void) const + { + return GetFieldNumValues(108, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_cadence_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCadencePositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(108); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_cadence_position field + // Units: rpm + // Comment: Average cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgCadencePosition(FIT_UINT8 index) const + { + return GetFieldUINT8Value(108, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_cadence_position field + // Units: rpm + // Comment: Average cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgCadencePosition(FIT_UINT8 index, FIT_UINT8 avgCadencePosition) + { + SetFieldUINT8Value(108, avgCadencePosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_cadence_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxCadencePosition(void) const + { + return GetFieldNumValues(109, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_cadence_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCadencePositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(109); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_cadence_position field + // Units: rpm + // Comment: Maximum cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxCadencePosition(FIT_UINT8 index) const + { + return GetFieldUINT8Value(109, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_cadence_position field + // Units: rpm + // Comment: Maximum cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetMaxCadencePosition(FIT_UINT8 index, FIT_UINT8 maxCadencePosition) + { + SetFieldUINT8Value(109, maxCadencePosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgSpeedValid() const + { + const Field* field = GetField(110); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgSpeed(void) const + { + return GetFieldFLOAT32Value(110, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgSpeed(FIT_FLOAT32 enhancedAvgSpeed) + { + SetFieldFLOAT32Value(110, enhancedAvgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxSpeedValid() const + { + const Field* field = GetField(111); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxSpeed(void) const + { + return GetFieldFLOAT32Value(111, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxSpeed(FIT_FLOAT32 enhancedMaxSpeed) + { + SetFieldFLOAT32Value(111, enhancedMaxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgAltitudeValid() const + { + const Field* field = GetField(112); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgAltitude(void) const + { + return GetFieldFLOAT32Value(112, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgAltitude(FIT_FLOAT32 enhancedAvgAltitude) + { + SetFieldFLOAT32Value(112, enhancedAvgAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_min_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMinAltitudeValid() const + { + const Field* field = GetField(113); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMinAltitude(void) const + { + return GetFieldFLOAT32Value(113, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMinAltitude(FIT_FLOAT32 enhancedMinAltitude) + { + SetFieldFLOAT32Value(113, enhancedMinAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxAltitudeValid() const + { + const Field* field = GetField(114); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxAltitude(void) const + { + return GetFieldFLOAT32Value(114, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxAltitude(FIT_FLOAT32 enhancedMaxAltitude) + { + SetFieldFLOAT32Value(114, enhancedMaxAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_lev_motor_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLevMotorPowerValid() const + { + const Field* field = GetField(115); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_lev_motor_power field + // Units: watts + // Comment: lev average motor power during lap + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgLevMotorPower(void) const + { + return GetFieldUINT16Value(115, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_lev_motor_power field + // Units: watts + // Comment: lev average motor power during lap + /////////////////////////////////////////////////////////////////////// + void SetAvgLevMotorPower(FIT_UINT16 avgLevMotorPower) + { + SetFieldUINT16Value(115, avgLevMotorPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_lev_motor_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxLevMotorPowerValid() const + { + const Field* field = GetField(116); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_lev_motor_power field + // Units: watts + // Comment: lev maximum motor power during lap + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxLevMotorPower(void) const + { + return GetFieldUINT16Value(116, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_lev_motor_power field + // Units: watts + // Comment: lev maximum motor power during lap + /////////////////////////////////////////////////////////////////////// + void SetMaxLevMotorPower(FIT_UINT16 maxLevMotorPower) + { + SetFieldUINT16Value(116, maxLevMotorPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of lev_battery_consumption field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLevBatteryConsumptionValid() const + { + const Field* field = GetField(117); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns lev_battery_consumption field + // Units: percent + // Comment: lev battery consumption during lap + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLevBatteryConsumption(void) const + { + return GetFieldFLOAT32Value(117, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set lev_battery_consumption field + // Units: percent + // Comment: lev battery consumption during lap + /////////////////////////////////////////////////////////////////////// + void SetLevBatteryConsumption(FIT_FLOAT32 levBatteryConsumption) + { + SetFieldFLOAT32Value(117, levBatteryConsumption, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vertical_ratio field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVerticalRatioValid() const + { + const Field* field = GetField(118); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vertical_ratio field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVerticalRatio(void) const + { + return GetFieldFLOAT32Value(118, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vertical_ratio field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgVerticalRatio(FIT_FLOAT32 avgVerticalRatio) + { + SetFieldFLOAT32Value(118, avgVerticalRatio, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stance_time_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStanceTimeBalanceValid() const + { + const Field* field = GetField(119); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stance_time_balance field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStanceTimeBalance(void) const + { + return GetFieldFLOAT32Value(119, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stance_time_balance field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgStanceTimeBalance(FIT_FLOAT32 avgStanceTimeBalance) + { + SetFieldFLOAT32Value(119, avgStanceTimeBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_step_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStepLengthValid() const + { + const Field* field = GetField(120); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_step_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStepLength(void) const + { + return GetFieldFLOAT32Value(120, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_step_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetAvgStepLength(FIT_FLOAT32 avgStepLength) + { + SetFieldFLOAT32Value(120, avgStepLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vam field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVamValid() const + { + const Field* field = GetField(121); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vam field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVam(void) const + { + return GetFieldFLOAT32Value(121, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vam field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgVam(FIT_FLOAT32 avgVam) + { + SetFieldFLOAT32Value(121, avgVam, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgDepthValid() const + { + const Field* field = GetField(122); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgDepth(void) const + { + return GetFieldFLOAT32Value(122, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetAvgDepth(FIT_FLOAT32 avgDepth) + { + SetFieldFLOAT32Value(122, avgDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxDepthValid() const + { + const Field* field = GetField(123); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxDepth(void) const + { + return GetFieldFLOAT32Value(123, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetMaxDepth(FIT_FLOAT32 maxDepth) + { + SetFieldFLOAT32Value(123, maxDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinTemperatureValid() const + { + const Field* field = GetField(124); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetMinTemperature(void) const + { + return GetFieldSINT8Value(124, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMinTemperature(FIT_SINT8 minTemperature) + { + SetFieldSINT8Value(124, minTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgRespirationRateValid() const + { + const Field* field = GetField(136); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgRespirationRate(void) const + { + return GetFieldFLOAT32Value(136, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgRespirationRate(FIT_FLOAT32 enhancedAvgRespirationRate) + { + SetFieldFLOAT32Value(136, enhancedAvgRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxRespirationRateValid() const + { + const Field* field = GetField(137); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxRespirationRate(void) const + { + return GetFieldFLOAT32Value(137, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxRespirationRate(FIT_FLOAT32 enhancedMaxRespirationRate) + { + SetFieldFLOAT32Value(137, enhancedMaxRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRespirationRateValid() const + { + const Field* field = GetField(147); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgRespirationRate(void) const + { + return GetFieldUINT8Value(147, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetAvgRespirationRate(FIT_UINT8 avgRespirationRate) + { + SetFieldUINT8Value(147, avgRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxRespirationRateValid() const + { + const Field* field = GetField(148); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxRespirationRate(void) const + { + return GetFieldUINT8Value(148, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetMaxRespirationRate(FIT_UINT8 maxRespirationRate) + { + SetFieldUINT8Value(148, maxRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalGritValid() const + { + const Field* field = GetField(149); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalGrit(void) const + { + return GetFieldFLOAT32Value(149, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetTotalGrit(FIT_FLOAT32 totalGrit) + { + SetFieldFLOAT32Value(149, totalGrit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFlowValid() const + { + const Field* field = GetField(150); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFlow(void) const + { + return GetFieldFLOAT32Value(150, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetTotalFlow(FIT_FLOAT32 totalFlow) + { + SetFieldFLOAT32Value(150, totalFlow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of jump_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsJumpCountValid() const + { + const Field* field = GetField(151); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns jump_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetJumpCount(void) const + { + return GetFieldUINT16Value(151, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set jump_count field + /////////////////////////////////////////////////////////////////////// + void SetJumpCount(FIT_UINT16 jumpCount) + { + SetFieldUINT16Value(151, jumpCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgGritValid() const + { + const Field* field = GetField(153); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgGrit(void) const + { + return GetFieldFLOAT32Value(153, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetAvgGrit(FIT_FLOAT32 avgGrit) + { + SetFieldFLOAT32Value(153, avgGrit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgFlowValid() const + { + const Field* field = GetField(154); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgFlow(void) const + { + return GetFieldFLOAT32Value(154, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetAvgFlow(FIT_FLOAT32 avgFlow) + { + SetFieldFLOAT32Value(154, avgFlow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalAscentValid() const + { + const Field* field = GetField(156); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_ascent field + // Units: m + // Comment: fractional part of total_ascent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalAscent(void) const + { + return GetFieldFLOAT32Value(156, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_ascent field + // Units: m + // Comment: fractional part of total_ascent + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalAscent(FIT_FLOAT32 totalFractionalAscent) + { + SetFieldFLOAT32Value(156, totalFractionalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalDescentValid() const + { + const Field* field = GetField(157); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_descent field + // Units: m + // Comment: fractional part of total_descent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalDescent(void) const + { + return GetFieldFLOAT32Value(157, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_descent field + // Units: m + // Comment: fractional part of total_descent + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalDescent(FIT_FLOAT32 totalFractionalDescent) + { + SetFieldFLOAT32Value(157, totalFractionalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCoreTemperatureValid() const + { + const Field* field = GetField(158); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgCoreTemperature(void) const + { + return GetFieldFLOAT32Value(158, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetAvgCoreTemperature(FIT_FLOAT32 avgCoreTemperature) + { + SetFieldFLOAT32Value(158, avgCoreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinCoreTemperatureValid() const + { + const Field* field = GetField(159); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinCoreTemperature(void) const + { + return GetFieldFLOAT32Value(159, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMinCoreTemperature(FIT_FLOAT32 minCoreTemperature) + { + SetFieldFLOAT32Value(159, minCoreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCoreTemperatureValid() const + { + const Field* field = GetField(160); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxCoreTemperature(void) const + { + return GetFieldFLOAT32Value(160, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMaxCoreTemperature(FIT_FLOAT32 maxCoreTemperature) + { + SetFieldFLOAT32Value(160, maxCoreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_LAP_MESG_HPP) diff --git a/fit_lap_mesg_listener.hpp b/fit_lap_mesg_listener.hpp new file mode 100644 index 0000000..2aa053b --- /dev/null +++ b/fit_lap_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_LAP_MESG_LISTENER_HPP) +#define FIT_LAP_MESG_LISTENER_HPP + +#include "fit_lap_mesg.hpp" + +namespace fit +{ + +class LapMesgListener +{ +public: + virtual ~LapMesgListener() {} + virtual void OnMesg(LapMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_LAP_MESG_LISTENER_HPP) diff --git a/fit_length_mesg.hpp b/fit_length_mesg.hpp new file mode 100644 index 0000000..58cdd0a --- /dev/null +++ b/fit_length_mesg.hpp @@ -0,0 +1,789 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_LENGTH_MESG_HPP) +#define FIT_LENGTH_MESG_HPP + +#include "fit_mesg.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class LengthMesg : public Mesg, public MesgWithEvent +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Event = 0; + static const FIT_UINT8 EventType = 1; + static const FIT_UINT8 StartTime = 2; + static const FIT_UINT8 TotalElapsedTime = 3; + static const FIT_UINT8 TotalTimerTime = 4; + static const FIT_UINT8 TotalStrokes = 5; + static const FIT_UINT8 AvgSpeed = 6; + static const FIT_UINT8 SwimStroke = 7; + static const FIT_UINT8 AvgSwimmingCadence = 9; + static const FIT_UINT8 EventGroup = 10; + static const FIT_UINT8 TotalCalories = 11; + static const FIT_UINT8 LengthType = 12; + static const FIT_UINT8 PlayerScore = 18; + static const FIT_UINT8 OpponentScore = 19; + static const FIT_UINT8 StrokeCount = 20; + static const FIT_UINT8 ZoneCount = 21; + static const FIT_UINT8 EnhancedAvgRespirationRate = 22; + static const FIT_UINT8 EnhancedMaxRespirationRate = 23; + static const FIT_UINT8 AvgRespirationRate = 24; + static const FIT_UINT8 MaxRespirationRate = 25; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + LengthMesg(void) : Mesg(Profile::MESG_LENGTH) + { + } + + LengthMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT GetEvent(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event field + /////////////////////////////////////////////////////////////////////// + void SetEvent(FIT_EVENT event) + { + SetFieldENUMValue(0, event, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_type field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT_TYPE GetEventType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_type field + /////////////////////////////////////////////////////////////////////// + void SetEventType(FIT_EVENT_TYPE eventType) + { + SetFieldENUMValue(1, eventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTime(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_time field + /////////////////////////////////////////////////////////////////////// + void SetStartTime(FIT_DATE_TIME startTime) + { + SetFieldUINT32Value(2, startTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_elapsed_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalElapsedTimeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_elapsed_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalElapsedTime(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_elapsed_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalElapsedTime(FIT_FLOAT32 totalElapsedTime) + { + SetFieldFLOAT32Value(3, totalElapsedTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(4, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_strokes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalStrokesValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalStrokes(void) const + { + return GetFieldUINT16Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + void SetTotalStrokes(FIT_UINT16 totalStrokes) + { + SetFieldUINT16Value(5, totalStrokes, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(6, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swim_stroke field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwimStrokeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swim_stroke field + // Units: swim_stroke + /////////////////////////////////////////////////////////////////////// + FIT_SWIM_STROKE GetSwimStroke(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swim_stroke field + // Units: swim_stroke + /////////////////////////////////////////////////////////////////////// + void SetSwimStroke(FIT_SWIM_STROKE swimStroke) + { + SetFieldENUMValue(7, swimStroke, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_swimming_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSwimmingCadenceValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_swimming_cadence field + // Units: strokes/min + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgSwimmingCadence(void) const + { + return GetFieldUINT8Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_swimming_cadence field + // Units: strokes/min + /////////////////////////////////////////////////////////////////////// + void SetAvgSwimmingCadence(FIT_UINT8 avgSwimmingCadence) + { + SetFieldUINT8Value(9, avgSwimmingCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_group field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventGroupValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_group field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventGroup(void) const + { + return GetFieldUINT8Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_group field + /////////////////////////////////////////////////////////////////////// + void SetEventGroup(FIT_UINT8 eventGroup) + { + SetFieldUINT8Value(10, eventGroup, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCaloriesValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalCalories(void) const + { + return GetFieldUINT16Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalCalories(FIT_UINT16 totalCalories) + { + SetFieldUINT16Value(11, totalCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of length_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLengthTypeValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns length_type field + /////////////////////////////////////////////////////////////////////// + FIT_LENGTH_TYPE GetLengthType(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set length_type field + /////////////////////////////////////////////////////////////////////// + void SetLengthType(FIT_LENGTH_TYPE lengthType) + { + SetFieldENUMValue(12, lengthType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of player_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPlayerScoreValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns player_score field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPlayerScore(void) const + { + return GetFieldUINT16Value(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set player_score field + /////////////////////////////////////////////////////////////////////// + void SetPlayerScore(FIT_UINT16 playerScore) + { + SetFieldUINT16Value(18, playerScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of opponent_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOpponentScoreValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns opponent_score field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetOpponentScore(void) const + { + return GetFieldUINT16Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set opponent_score field + /////////////////////////////////////////////////////////////////////// + void SetOpponentScore(FIT_UINT16 opponentScore) + { + SetFieldUINT16Value(19, opponentScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of stroke_count + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumStrokeCount(void) const + { + return GetFieldNumValues(20, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stroke_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStrokeCountValid(FIT_UINT8 index) const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stroke_count field + // Units: counts + // Comment: stroke_type enum used as the index + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStrokeCount(FIT_UINT8 index) const + { + return GetFieldUINT16Value(20, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stroke_count field + // Units: counts + // Comment: stroke_type enum used as the index + /////////////////////////////////////////////////////////////////////// + void SetStrokeCount(FIT_UINT8 index, FIT_UINT16 strokeCount) + { + SetFieldUINT16Value(20, strokeCount, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of zone_count + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumZoneCount(void) const + { + return GetFieldNumValues(21, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of zone_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsZoneCountValid(FIT_UINT8 index) const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns zone_count field + // Units: counts + // Comment: zone number used as the index + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetZoneCount(FIT_UINT8 index) const + { + return GetFieldUINT16Value(21, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set zone_count field + // Units: counts + // Comment: zone number used as the index + /////////////////////////////////////////////////////////////////////// + void SetZoneCount(FIT_UINT8 index, FIT_UINT16 zoneCount) + { + SetFieldUINT16Value(21, zoneCount, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgRespirationRateValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgRespirationRate(void) const + { + return GetFieldFLOAT32Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgRespirationRate(FIT_FLOAT32 enhancedAvgRespirationRate) + { + SetFieldFLOAT32Value(22, enhancedAvgRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxRespirationRateValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxRespirationRate(void) const + { + return GetFieldFLOAT32Value(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxRespirationRate(FIT_FLOAT32 enhancedMaxRespirationRate) + { + SetFieldFLOAT32Value(23, enhancedMaxRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRespirationRateValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgRespirationRate(void) const + { + return GetFieldUINT8Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetAvgRespirationRate(FIT_UINT8 avgRespirationRate) + { + SetFieldUINT8Value(24, avgRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxRespirationRateValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxRespirationRate(void) const + { + return GetFieldUINT8Value(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetMaxRespirationRate(FIT_UINT8 maxRespirationRate) + { + SetFieldUINT8Value(25, maxRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_LENGTH_MESG_HPP) diff --git a/fit_length_mesg_listener.hpp b/fit_length_mesg_listener.hpp new file mode 100644 index 0000000..5e25002 --- /dev/null +++ b/fit_length_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_LENGTH_MESG_LISTENER_HPP) +#define FIT_LENGTH_MESG_LISTENER_HPP + +#include "fit_length_mesg.hpp" + +namespace fit +{ + +class LengthMesgListener +{ +public: + virtual ~LengthMesgListener() {} + virtual void OnMesg(LengthMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_LENGTH_MESG_LISTENER_HPP) diff --git a/fit_magnetometer_data_mesg.hpp b/fit_magnetometer_data_mesg.hpp new file mode 100644 index 0000000..afc0323 --- /dev/null +++ b/fit_magnetometer_data_mesg.hpp @@ -0,0 +1,422 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MAGNETOMETER_DATA_MESG_HPP) +#define FIT_MAGNETOMETER_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MagnetometerDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 SampleTimeOffset = 1; + static const FIT_UINT8 MagX = 2; + static const FIT_UINT8 MagY = 3; + static const FIT_UINT8 MagZ = 4; + static const FIT_UINT8 CalibratedMagX = 5; + static const FIT_UINT8 CalibratedMagY = 6; + static const FIT_UINT8 CalibratedMagZ = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MagnetometerDataMesg(void) : Mesg(Profile::MESG_MAGNETOMETER_DATA) + { + } + + MagnetometerDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of sample_time_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSampleTimeOffset(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sample_time_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSampleTimeOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the compass sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in cmps_x and cmps_y and cmps_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSampleTimeOffset(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sample_time_offset field + // Units: ms + // Comment: Each time in the array describes the time at which the compass sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in cmps_x and cmps_y and cmps_z + /////////////////////////////////////////////////////////////////////// + void SetSampleTimeOffset(FIT_UINT8 index, FIT_UINT16 sampleTimeOffset) + { + SetFieldUINT16Value(1, sampleTimeOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of mag_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMagX(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mag_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMagXValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mag_x field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMagX(FIT_UINT8 index) const + { + return GetFieldUINT16Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mag_x field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetMagX(FIT_UINT8 index, FIT_UINT16 magX) + { + SetFieldUINT16Value(2, magX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of mag_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMagY(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mag_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMagYValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mag_y field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMagY(FIT_UINT8 index) const + { + return GetFieldUINT16Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mag_y field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetMagY(FIT_UINT8 index, FIT_UINT16 magY) + { + SetFieldUINT16Value(3, magY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of mag_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMagZ(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mag_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMagZValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mag_z field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMagZ(FIT_UINT8 index) const + { + return GetFieldUINT16Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mag_z field + // Units: counts + // Comment: These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read. + /////////////////////////////////////////////////////////////////////// + void SetMagZ(FIT_UINT8 index, FIT_UINT16 magZ) + { + SetFieldUINT16Value(4, magZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_mag_x + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedMagX(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_mag_x field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedMagXValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_mag_x field + // Units: G + // Comment: Calibrated Magnetometer reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedMagX(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_mag_x field + // Units: G + // Comment: Calibrated Magnetometer reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedMagX(FIT_UINT8 index, FIT_FLOAT32 calibratedMagX) + { + SetFieldFLOAT32Value(5, calibratedMagX, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_mag_y + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedMagY(void) const + { + return GetFieldNumValues(6, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_mag_y field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedMagYValid(FIT_UINT8 index) const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_mag_y field + // Units: G + // Comment: Calibrated Magnetometer reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedMagY(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(6, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_mag_y field + // Units: G + // Comment: Calibrated Magnetometer reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedMagY(FIT_UINT8 index, FIT_FLOAT32 calibratedMagY) + { + SetFieldFLOAT32Value(6, calibratedMagY, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of calibrated_mag_z + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCalibratedMagZ(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_mag_z field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedMagZValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_mag_z field + // Units: G + // Comment: Calibrated Magnetometer reading + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalibratedMagZ(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_mag_z field + // Units: G + // Comment: Calibrated Magnetometer reading + /////////////////////////////////////////////////////////////////////// + void SetCalibratedMagZ(FIT_UINT8 index, FIT_FLOAT32 calibratedMagZ) + { + SetFieldFLOAT32Value(7, calibratedMagZ, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MAGNETOMETER_DATA_MESG_HPP) diff --git a/fit_magnetometer_data_mesg_listener.hpp b/fit_magnetometer_data_mesg_listener.hpp new file mode 100644 index 0000000..554e5ec --- /dev/null +++ b/fit_magnetometer_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MAGNETOMETER_DATA_MESG_LISTENER_HPP) +#define FIT_MAGNETOMETER_DATA_MESG_LISTENER_HPP + +#include "fit_magnetometer_data_mesg.hpp" + +namespace fit +{ + +class MagnetometerDataMesgListener +{ +public: + virtual ~MagnetometerDataMesgListener() {} + virtual void OnMesg(MagnetometerDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MAGNETOMETER_DATA_MESG_LISTENER_HPP) diff --git a/fit_max_met_data_mesg.hpp b/fit_max_met_data_mesg.hpp new file mode 100644 index 0000000..fcc452c --- /dev/null +++ b/fit_max_met_data_mesg.hpp @@ -0,0 +1,308 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MAX_MET_DATA_MESG_HPP) +#define FIT_MAX_MET_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MaxMetDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 UpdateTime = 0; + static const FIT_UINT8 Vo2Max = 2; + static const FIT_UINT8 Sport = 5; + static const FIT_UINT8 SubSport = 6; + static const FIT_UINT8 MaxMetCategory = 8; + static const FIT_UINT8 CalibratedData = 9; + static const FIT_UINT8 HrSource = 12; + static const FIT_UINT8 SpeedSource = 13; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MaxMetDataMesg(void) : Mesg(Profile::MESG_MAX_MET_DATA) + { + } + + MaxMetDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of update_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUpdateTimeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns update_time field + // Comment: Time maxMET and vo2 were calculated + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetUpdateTime(void) const + { + return GetFieldUINT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set update_time field + // Comment: Time maxMET and vo2 were calculated + /////////////////////////////////////////////////////////////////////// + void SetUpdateTime(FIT_DATE_TIME updateTime) + { + SetFieldUINT32Value(0, updateTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of vo2_max field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVo2MaxValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns vo2_max field + // Units: mL/kg/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVo2Max(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set vo2_max field + // Units: mL/kg/min + /////////////////////////////////////////////////////////////////////// + void SetVo2Max(FIT_FLOAT32 vo2Max) + { + SetFieldFLOAT32Value(2, vo2Max, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(5, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(6, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_met_category field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxMetCategoryValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_met_category field + /////////////////////////////////////////////////////////////////////// + FIT_MAX_MET_CATEGORY GetMaxMetCategory(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_met_category field + /////////////////////////////////////////////////////////////////////// + void SetMaxMetCategory(FIT_MAX_MET_CATEGORY maxMetCategory) + { + SetFieldENUMValue(8, maxMetCategory, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibrated_data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibratedDataValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibrated_data field + // Comment: Indicates if calibrated data was used in the calculation + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetCalibratedData(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibrated_data field + // Comment: Indicates if calibrated data was used in the calculation + /////////////////////////////////////////////////////////////////////// + void SetCalibratedData(FIT_BOOL calibratedData) + { + SetFieldENUMValue(9, calibratedData, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_source field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrSourceValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hr_source field + // Comment: Indicates if the estimate was obtained using a chest strap or wrist heart rate + /////////////////////////////////////////////////////////////////////// + FIT_MAX_MET_HEART_RATE_SOURCE GetHrSource(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_source field + // Comment: Indicates if the estimate was obtained using a chest strap or wrist heart rate + /////////////////////////////////////////////////////////////////////// + void SetHrSource(FIT_MAX_MET_HEART_RATE_SOURCE hrSource) + { + SetFieldENUMValue(12, hrSource, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_source field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedSourceValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed_source field + // Comment: Indidcates if the estimate was obtained using onboard GPS or connected GPS + /////////////////////////////////////////////////////////////////////// + FIT_MAX_MET_SPEED_SOURCE GetSpeedSource(void) const + { + return GetFieldENUMValue(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_source field + // Comment: Indidcates if the estimate was obtained using onboard GPS or connected GPS + /////////////////////////////////////////////////////////////////////// + void SetSpeedSource(FIT_MAX_MET_SPEED_SOURCE speedSource) + { + SetFieldENUMValue(13, speedSource, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MAX_MET_DATA_MESG_HPP) diff --git a/fit_max_met_data_mesg_listener.hpp b/fit_max_met_data_mesg_listener.hpp new file mode 100644 index 0000000..c06a5b5 --- /dev/null +++ b/fit_max_met_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MAX_MET_DATA_MESG_LISTENER_HPP) +#define FIT_MAX_MET_DATA_MESG_LISTENER_HPP + +#include "fit_max_met_data_mesg.hpp" + +namespace fit +{ + +class MaxMetDataMesgListener +{ +public: + virtual ~MaxMetDataMesgListener() {} + virtual void OnMesg(MaxMetDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MAX_MET_DATA_MESG_LISTENER_HPP) diff --git a/fit_memo_glob_mesg.hpp b/fit_memo_glob_mesg.hpp new file mode 100644 index 0000000..a252442 --- /dev/null +++ b/fit_memo_glob_mesg.hpp @@ -0,0 +1,262 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MEMO_GLOB_MESG_HPP) +#define FIT_MEMO_GLOB_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MemoGlobMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 PartIndex = 250; + static const FIT_UINT8 Memo = 0; + static const FIT_UINT8 MesgNum = 1; + static const FIT_UINT8 ParentIndex = 2; + static const FIT_UINT8 FieldNum = 3; + static const FIT_UINT8 Data = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MemoGlobMesg(void) : Mesg(Profile::MESG_MEMO_GLOB) + { + } + + MemoGlobMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of part_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPartIndexValid() const + { + const Field* field = GetField(250); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns part_index field + // Comment: Sequence number of memo blocks + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetPartIndex(void) const + { + return GetFieldUINT32Value(250, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set part_index field + // Comment: Sequence number of memo blocks + /////////////////////////////////////////////////////////////////////// + void SetPartIndex(FIT_UINT32 partIndex) + { + SetFieldUINT32Value(250, partIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of memo + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMemo(void) const + { + return GetFieldNumValues(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of memo field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMemoValid(FIT_UINT8 index) const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns memo field + // Comment: Deprecated. Use data field. + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetMemo(FIT_UINT8 index) const + { + return GetFieldBYTEValue(0, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set memo field + // Comment: Deprecated. Use data field. + /////////////////////////////////////////////////////////////////////// + void SetMemo(FIT_UINT8 index, FIT_BYTE memo) + { + SetFieldBYTEValue(0, memo, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgNumValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_num field + // Comment: Message Number of the parent message + /////////////////////////////////////////////////////////////////////// + FIT_MESG_NUM GetMesgNum(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_num field + // Comment: Message Number of the parent message + /////////////////////////////////////////////////////////////////////// + void SetMesgNum(FIT_MESG_NUM mesgNum) + { + SetFieldUINT16Value(1, mesgNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of parent_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsParentIndexValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns parent_index field + // Comment: Index of mesg that this glob is associated with. + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetParentIndex(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set parent_index field + // Comment: Index of mesg that this glob is associated with. + /////////////////////////////////////////////////////////////////////// + void SetParentIndex(FIT_MESSAGE_INDEX parentIndex) + { + SetFieldUINT16Value(2, parentIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of field_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFieldNumValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns field_num field + // Comment: Field within the parent that this glob is associated with + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetFieldNum(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set field_num field + // Comment: Field within the parent that this glob is associated with + /////////////////////////////////////////////////////////////////////// + void SetFieldNum(FIT_UINT8 fieldNum) + { + SetFieldUINT8Value(3, fieldNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumData(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data field + // Comment: Block of utf8 bytes. Note, mutltibyte characters may be split across adjoining memo_glob messages. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetData(FIT_UINT8 index) const + { + return GetFieldUINT8ZValue(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data field + // Comment: Block of utf8 bytes. Note, mutltibyte characters may be split across adjoining memo_glob messages. + /////////////////////////////////////////////////////////////////////// + void SetData(FIT_UINT8 index, FIT_UINT8Z data) + { + SetFieldUINT8ZValue(4, data, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MEMO_GLOB_MESG_HPP) diff --git a/fit_memo_glob_mesg_listener.hpp b/fit_memo_glob_mesg_listener.hpp new file mode 100644 index 0000000..53db5ef --- /dev/null +++ b/fit_memo_glob_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MEMO_GLOB_MESG_LISTENER_HPP) +#define FIT_MEMO_GLOB_MESG_LISTENER_HPP + +#include "fit_memo_glob_mesg.hpp" + +namespace fit +{ + +class MemoGlobMesgListener +{ +public: + virtual ~MemoGlobMesgListener() {} + virtual void OnMesg(MemoGlobMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MEMO_GLOB_MESG_LISTENER_HPP) diff --git a/fit_mesg.cpp b/fit_mesg.cpp new file mode 100644 index 0000000..82364c4 --- /dev/null +++ b/fit_mesg.cpp @@ -0,0 +1,916 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include +#include "fit_mesg.hpp" +#include "fit_mesg_definition.hpp" + +namespace fit +{ + +Mesg::Mesg() + : profile(FIT_NULL) + , localNum(0) + , fields() + , devFields() +{ +} + +Mesg::Mesg(const Mesg &mesg) + : profile(mesg.profile) + , localNum(mesg.localNum) + , fields(mesg.fields) + , devFields(mesg.devFields) +{ +} + +Mesg::Mesg(const Profile::MESG_INDEX index) + : profile(&Profile::mesgs[index]) + , localNum(0) + , fields() + , devFields() +{ +} + +Mesg::Mesg(const std::string& name) + : profile(Profile::GetMesg(name)) + , localNum(0) + , fields() + , devFields() +{ +} + +Mesg::Mesg(const FIT_UINT16 num) + : profile(Profile::GetMesg(num)) + , localNum(0) + , fields() + , devFields() +{ +} + +FIT_BOOL Mesg::IsValid(void) const +{ + return (profile != FIT_NULL); +} + +FIT_BOOL Mesg::GetIsFieldAccumulated(const FIT_UINT8 num) const +{ + const Field *field = this->GetField(num); + if (field != FIT_NULL) + { + return field->GetIsAccumulated(); + } + return FIT_FALSE; +} + +const DeveloperField* Mesg::GetDeveloperField(FIT_UINT8 developerDataIndex, FIT_UINT8 num) const +{ + for (int i = 0; i < (int)devFields.size(); i++) + { + const DeveloperFieldDefinition& def = devFields[i].GetDefinition(); + if ((def.GetNum() == num) && + (def.GetDeveloperDataIndex() == developerDataIndex)) + { + return &devFields[i]; + } + } + + return FIT_NULL; +} + +int Mesg::Write(std::ostream& file, const MesgDefinition* mesgDef) const +{ + MesgDefinition mesgDefOnNull; + int mesgSize = 1; + int fieldSize = 0; + + file.put((localNum & FIT_HDR_TYPE_MASK)); // Message record header with local message number. + + if (mesgDef == FIT_NULL) + { + mesgDefOnNull = MesgDefinition(*this); + mesgDef = &mesgDefOnNull; + } + + for (FIT_UINT16 fieldDefIndex = 0; fieldDefIndex < (mesgDef->GetFields().size()); fieldDefIndex++) + { + const Field* field = GetField(mesgDef->GetFieldByIndex(fieldDefIndex)->GetNum()); + const FieldDefinition* definition = mesgDef->GetFieldByIndex(fieldDefIndex); + + fieldSize = WriteField(file, field, definition->GetSize(), definition->GetType()); + if (fieldSize == 0) + { + // Something went wrong during our write + return 0; + } + + mesgSize += fieldSize; + } + + for (DeveloperFieldDefinition def : mesgDef->GetDevFields()) + { + const DeveloperField* field = GetDeveloperField(def.GetDeveloperDataIndex(), def.GetNum()); + + fieldSize = WriteField(file, field, def.GetSize(), def.GetType()); + if (fieldSize == 0) + { + // Something went wrong during our write + return 0; + } + + mesgSize += fieldSize; + } + + return mesgSize; +} + +std::string Mesg::GetName() const +{ + if (profile == FIT_NULL) + return "unknown"; + + return profile->name; +} + +FIT_UINT16 Mesg::GetNum() const +{ + if (profile == FIT_NULL) + return FIT_MESG_NUM_INVALID; + + return profile->num; +} + +FIT_UINT8 Mesg::GetLocalNum() const +{ + return localNum; +} + +void Mesg::SetLocalNum(const FIT_UINT8 newLocalNum) +{ + if (newLocalNum < FIT_MAX_LOCAL_MESGS) + localNum = newLocalNum; +} + +FIT_BOOL Mesg::HasField(const int fieldNum) const +{ + for (int i = 0; i < (int)fields.size(); i++) + { + if (fields[i].GetNum() == fieldNum) + return FIT_TRUE; + } + + return FIT_FALSE; +} + +void Mesg::AddField(const Field& field) +{ + Field *existingField = GetField(field.GetNum()); + + if (existingField == FIT_NULL) + fields.push_back(field); +} + +Field* Mesg::AddField(const FIT_UINT8 fieldNum) +{ + Field *field = GetField(fieldNum); + + if (field == FIT_NULL) + { + fields.push_back(Field(profile->num, fieldNum)); + field = &fields[fields.size() - 1]; + } + + return field; +} + +void Mesg::AddDeveloperField(const DeveloperField& field) +{ + for (FIT_UINT16 i = 0; i < devFields.size(); ++i) + { + if (devFields[i].GetDefinition() == field.GetDefinition()) + { + devFields[i] = field; + return; + } + } + + devFields.push_back(field); +} + +void Mesg::SetField(const Field& field) +{ + for (int i = 0; i < (int)fields.size(); i++) + { + if (fields[i].GetNum() == field.GetNum()) + { + fields[i] = field; + return; + } + } + + fields.push_back(field); +} + +void Mesg::SetFields(const Mesg& mesg) +{ + if (mesg.GetNum() != GetNum()) + return; + + for (int i=0; i < (int)mesg.fields.size(); i++) + SetField(mesg.fields[i]); +} + +int Mesg::GetNumFields() const +{ + return (int)fields.size(); +} + +int Mesg::GetNumDevFields() const +{ + return (int)devFields.size(); +} + +Field* Mesg::GetFieldByIndex(const FIT_UINT16 index) +{ + if (index < fields.size()) + return &fields[index]; + + return FIT_NULL; +} + +Field* Mesg::GetField(const FIT_UINT8 fieldNum) +{ + for (int i = 0; i < (int)fields.size(); i++) + { + if (fields[i].GetNum() == fieldNum) + return &fields[i]; + } + + return FIT_NULL; +} + +Field* Mesg::GetField(const std::string& name) +{ + for (FIT_UINT16 i = 0; i < (FIT_UINT16)fields.size(); i++) + { + if (fields[i].GetName().compare(name) == 0) + return &fields[i]; + + for (FIT_UINT16 j = 0; j < fields[i].GetNumSubFields(); j++) + { + if ((fields[i].GetName(j).compare(name) == 0) && CanSupportSubField(&(fields[i]),j)) + return &fields[i]; + } + } + + return FIT_NULL; +} + +const Field* Mesg::GetFieldByIndex(const FIT_UINT16 index) const +{ + if (index < fields.size()) + return &fields[index]; + + return FIT_NULL; +} + +const Field* Mesg::GetField(const FIT_UINT8 fieldNum) const +{ + for (int i = 0; i < (int)fields.size(); i++) + { + if (fields[i].GetNum() == fieldNum) + return &fields[i]; + } + + return FIT_NULL; +} + +const Field* Mesg::GetField(const std::string& name) const +{ + for (FIT_UINT16 i = 0; i < (FIT_UINT16)fields.size(); i++) + { + if (fields[i].GetName().compare(name) == 0) + return &fields[i]; + + for (FIT_UINT16 j = 0; j < fields[i].GetNumSubFields(); j++) + { + if ((fields[i].GetName(j).compare(name) == 0) && CanSupportSubField(&(fields[i]),j)) + return &fields[i]; + } + } + + return FIT_NULL; +} + +const std::vector& Mesg::GetDeveloperFields() const +{ + return devFields; +} + +FIT_BOOL Mesg::CanSupportSubField(const FIT_UINT8 fieldNum, const FIT_UINT16 subFieldIndex) const +{ + if ((subFieldIndex == FIT_SUBFIELD_INDEX_MAIN_FIELD) || (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD)) + return FIT_TRUE; + + const Profile::SUBFIELD* subField = Profile::GetSubField(GetNum(), fieldNum, subFieldIndex); + + if (subField == FIT_NULL) + return FIT_FALSE; + + for (int i = 0; i < (int) subField->numMaps; i++) + { + const Field* refField = GetField(subField->maps[i].refFieldNum); + + if (refField != FIT_NULL) + { + FIT_FLOAT64 refValue = refField->GetFLOAT64Value(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + refValue += ((refValue >= 0.0) ? (0.5) : (-0.5)); + if ((FIT_SINT32)refValue == subField->maps[i].refFieldValue) + return FIT_TRUE; + } + } + + return FIT_FALSE; +} + +FIT_BOOL Mesg::CanSupportSubField(const Field* field, const FIT_UINT16 subFieldIndex) const +{ + if ((subFieldIndex == FIT_SUBFIELD_INDEX_MAIN_FIELD) || (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD)) + return FIT_TRUE; + + if (field == FIT_NULL) + return FIT_FALSE; + + const Profile::SUBFIELD* subField = field->GetSubField(subFieldIndex); + + if (subField == FIT_NULL) + return FIT_FALSE; + + for (int i = 0; i < (int) subField->numMaps; i++) + { + const Field* refField = GetField(subField->maps[i].refFieldNum); + + if (refField != FIT_NULL) + { + FIT_FLOAT64 refValue = refField->GetFLOAT64Value(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + refValue += ((refValue >= 0.0) ? (0.5) : (-0.5)); + if ((FIT_SINT32)refValue == subField->maps[i].refFieldValue) + return FIT_TRUE; + } + } + + return FIT_FALSE; +} + +FIT_UINT16 Mesg::GetActiveSubFieldIndexByFieldIndex(const FIT_UINT16 fieldIndex) const +{ + if ((int) fieldIndex >= GetNumFields()) + return FIT_SUBFIELD_INDEX_MAIN_FIELD; + + for (FIT_UINT16 i = 0; i < fields[fieldIndex].GetNumSubFields(); i++) + { + const Profile::SUBFIELD* subField = fields[fieldIndex].GetSubField(i); + + if (subField != FIT_NULL) + { + for (int j = 0; j < (int) subField->numMaps; j++) + { + const Field* refField = GetField(subField->maps[j].refFieldNum); + + if (refField != FIT_NULL) + { + FIT_FLOAT64 refValue = refField->GetFLOAT64Value(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + refValue += ((refValue >= 0.0) ? (0.5) : (-0.5)); + if ((FIT_SINT32)refValue == subField->maps[j].refFieldValue) + return ((FIT_UINT16) i); + } + } + } + } + + return FIT_SUBFIELD_INDEX_MAIN_FIELD; +} + +FIT_UINT16 Mesg::GetActiveSubFieldIndex(const FIT_UINT8 fieldNum) const +{ + const Profile::FIELD* field = Profile::GetField(GetNum(), fieldNum); + + if (field == FIT_NULL) + return FIT_SUBFIELD_INDEX_MAIN_FIELD; + + for (int i = 0; i < (int) field->numSubFields; i++) + { + const Profile::SUBFIELD& subField = field->subFields[i]; + + for (int j = 0; j < (int) subField.numMaps; j++) + { + const Field* refField = GetField(subField.maps[j].refFieldNum); + + if (refField != FIT_NULL) + { + FIT_FLOAT64 refValue = refField->GetFLOAT64Value(0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + refValue += ((refValue >= 0.0) ? (0.5) : (-0.5)); + if ((FIT_SINT32)refValue == subField.maps[j].refFieldValue) + return ((FIT_UINT16) i); + } + } + } + + return FIT_SUBFIELD_INDEX_MAIN_FIELD; +} + +FIT_UINT8 Mesg::GetFieldNumValues(const FIT_UINT8 fieldNum, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return 0; + + return field->GetNumValues(); +} + +FIT_ENUM Mesg::GetFieldENUMValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_ENUM_INVALID; + + return field->GetENUMValue(fieldArrayIndex); +} + +FIT_BYTE Mesg::GetFieldBYTEValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_BYTE_INVALID; + + return field->GetBYTEValue(fieldArrayIndex); +} + +FIT_SINT8 Mesg::GetFieldSINT8Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_SINT8_INVALID; + + return field->GetSINT8Value(fieldArrayIndex); +} + +FIT_UINT8 Mesg::GetFieldUINT8Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT8_INVALID; + + return field->GetUINT8Value(fieldArrayIndex); +} + +FIT_UINT8Z Mesg::GetFieldUINT8ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT8Z_INVALID; + + return field->GetUINT8ZValue(fieldArrayIndex); +} + +FIT_SINT16 Mesg::GetFieldSINT16Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_SINT16_INVALID; + + return field->GetSINT16Value(fieldArrayIndex); +} + +FIT_UINT16 Mesg::GetFieldUINT16Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT16_INVALID; + + return field->GetUINT16Value(fieldArrayIndex); +} + +FIT_UINT16Z Mesg::GetFieldUINT16ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT16Z_INVALID; + + return field->GetUINT16ZValue(fieldArrayIndex); +} + +FIT_SINT32 Mesg::GetFieldSINT32Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_SINT32_INVALID; + + return field->GetSINT32Value(fieldArrayIndex); +} + +FIT_UINT32 Mesg::GetFieldUINT32Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT32_INVALID; + + return field->GetUINT32Value(fieldArrayIndex); +} + +FIT_UINT32Z Mesg::GetFieldUINT32ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT32Z_INVALID; + + return field->GetUINT32ZValue(fieldArrayIndex); +} + +FIT_SINT64 Mesg::GetFieldSINT64Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_SINT64_INVALID; + + return field->GetSINT64Value(fieldArrayIndex); +} + +FIT_UINT64 Mesg::GetFieldUINT64Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT64_INVALID; + + return field->GetUINT64Value(fieldArrayIndex); +} + +FIT_UINT64Z Mesg::GetFieldUINT64ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_UINT64Z_INVALID; + + return field->GetUINT64ZValue(fieldArrayIndex); +} + +FIT_FLOAT32 Mesg::GetFieldFLOAT32Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_FLOAT32_INVALID; + + if (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) + return field->GetFLOAT32Value(fieldArrayIndex, GetActiveSubFieldIndex(fieldNum)); + else + return field->GetFLOAT32Value(fieldArrayIndex, subFieldIndex); +} + +FIT_FLOAT64 Mesg::GetFieldFLOAT64Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_FLOAT64_INVALID; + + if (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) + return field->GetFLOAT64Value(fieldArrayIndex, GetActiveSubFieldIndex(fieldNum)); + else + return field->GetFLOAT64Value(fieldArrayIndex, subFieldIndex); +} + +FIT_WSTRING Mesg::GetFieldSTRINGValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) const +{ + const Field *field = GetField(fieldNum); + + if ((field == FIT_NULL) || (!CanSupportSubField(fieldNum, subFieldIndex))) + return FIT_WSTRING_INVALID; + + if (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) + return field->GetSTRINGValue(fieldArrayIndex, GetActiveSubFieldIndex(fieldNum)); + else + return field->GetSTRINGValue(fieldArrayIndex, subFieldIndex); +} + +void Mesg::SetFieldENUMValue(const FIT_UINT8 fieldNum, const FIT_ENUM value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetENUMValue(value, fieldArrayIndex); +} + +void Mesg::SetFieldBYTEValue(const FIT_UINT8 fieldNum, const FIT_BYTE value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetBYTEValue(value, fieldArrayIndex); +} + +void Mesg::SetFieldSINT8Value(const FIT_UINT8 fieldNum, const FIT_SINT8 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetSINT8Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT8Value(const FIT_UINT8 fieldNum, const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT8Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT8ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT8ZValue(value, fieldArrayIndex); +} + +void Mesg::SetFieldSINT16Value(const FIT_UINT8 fieldNum, const FIT_SINT16 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetSINT16Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT16Value(const FIT_UINT8 fieldNum, const FIT_UINT16 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT16Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT16ZValue(const FIT_UINT8 fieldNum, const FIT_UINT16Z value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT16ZValue(value, fieldArrayIndex); +} + +void Mesg::SetFieldSINT32Value(const FIT_UINT8 fieldNum, const FIT_SINT32 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetSINT32Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT32Value(const FIT_UINT8 fieldNum, const FIT_UINT32 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT32Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT32ZValue(const FIT_UINT8 fieldNum, const FIT_UINT32Z value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT32ZValue(value, fieldArrayIndex); +} + +void Mesg::SetFieldSINT64Value(const FIT_UINT8 fieldNum, const FIT_SINT64 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetSINT64Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT64Value(const FIT_UINT8 fieldNum, const FIT_UINT64 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT64Value(value, fieldArrayIndex); +} + +void Mesg::SetFieldUINT64ZValue(const FIT_UINT8 fieldNum, const FIT_UINT64Z value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetUINT64ZValue(value, fieldArrayIndex); +} + +void Mesg::SetFieldFLOAT32Value(const FIT_UINT8 fieldNum, const FIT_FLOAT32 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + if (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) + return field->SetFLOAT32Value(value, fieldArrayIndex, GetActiveSubFieldIndex(fieldNum)); + else + return field->SetFLOAT32Value(value, fieldArrayIndex, subFieldIndex); +} + +void Mesg::SetFieldFLOAT64Value(const FIT_UINT8 fieldNum, const FIT_FLOAT64 value, const FIT_UINT8 fieldArrayIndex, const FIT_UINT16 subFieldIndex) +{ + if (!CanSupportSubField(fieldNum, subFieldIndex)) + return; + + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + if (subFieldIndex == FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) + return field->SetFLOAT64Value(value, fieldArrayIndex, GetActiveSubFieldIndex(fieldNum)); + else + return field->SetFLOAT64Value(value, fieldArrayIndex, subFieldIndex); +} + +void Mesg::SetFieldSTRINGValue(const FIT_UINT8 fieldNum, const FIT_WSTRING& value, const FIT_UINT8 fieldArrayIndex) +{ + Field *field = AddField(fieldNum); + + if (field == FIT_NULL) + return; + + return field->SetSTRINGValue(value, fieldArrayIndex); +} + +std::vector Mesg::GetOverrideFields(const FIT_UINT8 fieldNum) const +{ + std::vector vector; + + const FieldBase* nativeField = GetField(fieldNum); + + if (FIT_NULL != nativeField) + { + vector.emplace_back(nativeField); + } + + for (FIT_UINT32 i = 0; i < devFields.size(); i++) + { + const DeveloperField& devField = devFields[i]; + if (devField.GetNativeOverride() == fieldNum) + { + vector.emplace_back(&devField); + } + } + + return vector; +} + +void Mesg::RemoveExpandedFields(void) +{ + fields.erase(std::remove_if(fields.begin(), + fields.end(), + [](Field& field){return field.GetIsExpanded();}), + fields.end()); +} + +int Mesg::WriteField(std::ostream& file, const FieldBase* field, FIT_UINT8 defSize, FIT_UINT8 defType) +{ + FIT_UINT8 fieldSize = 0; + + if (field != FIT_NULL) + { + fieldSize = field->Write(file); + + if (fieldSize == 0) + return 0; + } + + if (fieldSize < defSize) + { + FIT_UINT8 baseTypeNum = (defType & FIT_BASE_TYPE_NUM_MASK); + + if (baseTypeNum < FIT_BASE_TYPES) + { + FIT_UINT8 baseTypeByteIndex = (fieldSize % (baseTypeSizes[baseTypeNum])); + FIT_UINT8 numBytesRemaining = (defSize) - fieldSize; + + while (numBytesRemaining--) + { + file.put(*(baseTypeInvalids[baseTypeNum] + baseTypeByteIndex)); + + if ((++baseTypeByteIndex) >= baseTypeSizes[baseTypeNum]) + baseTypeByteIndex = 0; + + fieldSize++; + } + } + else + { + return 0; + // Do not continue if base type not supported. + } + } + + return fieldSize; +} +} // namespace fit diff --git a/fit_mesg.hpp b/fit_mesg.hpp new file mode 100644 index 0000000..1ffb12a --- /dev/null +++ b/fit_mesg.hpp @@ -0,0 +1,114 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + + +#if !defined(FIT_MESG_HPP) +#define FIT_MESG_HPP + +#include +#include +#include +#include "fit.hpp" +#include "fit_field.hpp" +#include "fit_developer_field.hpp" +#include "fit_field_definition.hpp" + +namespace fit +{ +class MesgDefinition; // Forward declaration. + +class Mesg +{ +public: + Mesg(void); + Mesg(const Mesg &mesg); + Mesg(const Profile::MESG_INDEX index); + Mesg(const std::string& name); + Mesg(const FIT_UINT16 num); + FIT_BOOL IsValid(void) const; + FIT_BOOL GetIsFieldAccumulated(const FIT_UINT8 num) const; + const DeveloperField* GetDeveloperField(FIT_UINT8 developerDataIndex, FIT_UINT8 num) const; + int Write(std::ostream& file, const MesgDefinition* mesgDef = FIT_NULL) const; + std::string GetName() const; + FIT_UINT16 GetNum() const; + FIT_UINT8 GetLocalNum() const; + void SetLocalNum(const FIT_UINT8 newLocalNum); + FIT_BOOL HasField(const int fieldNum) const; + void AddField(const Field& field); + Field* AddField(const FIT_UINT8 fieldNum); + void AddDeveloperField(const DeveloperField& field); + void SetField(const Field& field); + void SetFields(const Mesg& mesg); + int GetNumFields() const; + int GetNumDevFields() const; + Field* GetFieldByIndex(const FIT_UINT16 index); + Field* GetField(const FIT_UINT8 fieldNum); + Field* GetField(const std::string& name); + const Field* GetFieldByIndex(const FIT_UINT16 index) const; + const Field* GetField(const FIT_UINT8 fieldNum) const; + const Field* GetField(const std::string& name) const; + const std::vector& GetDeveloperFields() const; + FIT_BOOL CanSupportSubField(const FIT_UINT8 fieldNum, const FIT_UINT16 subFieldIndex) const; + FIT_BOOL CanSupportSubField(const Field* field, const FIT_UINT16 subFieldIndex) const; + FIT_UINT16 GetActiveSubFieldIndexByFieldIndex(const FIT_UINT16 fieldIndex) const; + FIT_UINT16 GetActiveSubFieldIndex(const FIT_UINT8 fieldNum) const; + FIT_UINT8 GetFieldNumValues(const FIT_UINT8 fieldNum, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_ENUM GetFieldENUMValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_BYTE GetFieldBYTEValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_SINT8 GetFieldSINT8Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT8 GetFieldUINT8Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT8Z GetFieldUINT8ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_SINT16 GetFieldSINT16Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT16 GetFieldUINT16Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT16Z GetFieldUINT16ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_SINT32 GetFieldSINT32Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT32 GetFieldUINT32Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT32Z GetFieldUINT32ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_SINT64 GetFieldSINT64Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT64 GetFieldUINT64Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_UINT64Z GetFieldUINT64ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_FLOAT32 GetFieldFLOAT32Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_FLOAT64 GetFieldFLOAT64Value(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + FIT_WSTRING GetFieldSTRINGValue(const FIT_UINT8 fieldNum, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD) const; + void SetFieldENUMValue(const FIT_UINT8 fieldNum, const FIT_ENUM value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldBYTEValue(const FIT_UINT8 fieldNum, const FIT_BYTE value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldSINT8Value(const FIT_UINT8 fieldNum, const FIT_SINT8 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT8Value(const FIT_UINT8 fieldNum, const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT8ZValue(const FIT_UINT8 fieldNum, const FIT_UINT8 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldSINT16Value(const FIT_UINT8 fieldNum, const FIT_SINT16 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT16Value(const FIT_UINT8 fieldNum, const FIT_UINT16 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT16ZValue(const FIT_UINT8 fieldNum, const FIT_UINT16Z value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldSINT32Value(const FIT_UINT8 fieldNum, const FIT_SINT32 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT32Value(const FIT_UINT8 fieldNum, const FIT_UINT32 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT32ZValue(const FIT_UINT8 fieldNum, const FIT_UINT32Z value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldSINT64Value(const FIT_UINT8 fieldNum, const FIT_SINT64 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT64Value(const FIT_UINT8 fieldNum, const FIT_UINT64 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldUINT64ZValue(const FIT_UINT8 fieldNum, const FIT_UINT64Z value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldFLOAT32Value(const FIT_UINT8 fieldNum, const FIT_FLOAT32 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldFLOAT64Value(const FIT_UINT8 fieldNum, const FIT_FLOAT64 value, const FIT_UINT8 fieldArrayIndex = 0, const FIT_UINT16 subFieldIndex = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD); + void SetFieldSTRINGValue(const FIT_UINT8 fieldNum, const FIT_WSTRING& value, const FIT_UINT8 fieldArrayIndex = 0); + + std::vector GetOverrideFields(const FIT_UINT8 fieldNum) const; + void RemoveExpandedFields(void); + +private: + + static int WriteField(std::ostream& file, const FieldBase* field, FIT_UINT8 defSize, FIT_UINT8 defType); + const Profile::MESG* profile; + FIT_UINT8 localNum; + std::vector fields; + std::vector devFields; +}; + +} // namespace fit + +#endif // defined(FIT_MESG_HPP) diff --git a/fit_mesg_broadcast_plugin.hpp b/fit_mesg_broadcast_plugin.hpp new file mode 100644 index 0000000..406fee0 --- /dev/null +++ b/fit_mesg_broadcast_plugin.hpp @@ -0,0 +1,33 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + + +#if !defined(FIT_MESG_BROADCAST_PLUGIN_HPP) +#define FIT_MESG_BROADCAST_PLUGIN_HPP + +#include "fit.hpp" +#include "fit_mesg.hpp" + +namespace fit +{ + +class MesgBroadcastPlugin +{ +public: + virtual ~MesgBroadcastPlugin() { /* Empty destructor */ }; + virtual void OnBroadcast(std::vector& mesgs) = 0; + virtual void OnIncomingMesg(const Mesg& mesg) = 0; +}; + +} // namespace fit + +#endif // defined(FIT_MESG_BROADCAST_PLUGIN_HPP) diff --git a/fit_mesg_broadcaster.cpp b/fit_mesg_broadcaster.cpp new file mode 100644 index 0000000..eabbf38 --- /dev/null +++ b/fit_mesg_broadcaster.cpp @@ -0,0 +1,2573 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include "fit_mesg_broadcaster.hpp" +#include + +namespace fit +{ + +MesgBroadcaster::MesgBroadcaster(void) +{ +} + +FIT_BOOL MesgBroadcaster::Run(std::istream& file) +{ + Decode decode; + FIT_BOOL status = FIT_TRUE; + FIT_UINT32 fileSize = 0; + + // We can't guarantee that the file stream was reset + file.seekg(0, file.beg); + file.clear(); + // Read out the size of the file + file.seekg(0, file.end); + fileSize = (FIT_UINT32)file.tellg(); + // Ensure the read starts at the beginning of the file + file.seekg(0, file.beg); + file.clear(); + + status = decode.Read(file, *this, *this); + + return status; +} + +void MesgBroadcaster::AddListener(MesgDefinitionListener& mesgDefinitionListener) +{ + mesgDefinitionListeners.push_back(&mesgDefinitionListener); +} + +void MesgBroadcaster::RemoveListener(MesgDefinitionListener& mesgDefinitionListener) +{ + mesgDefinitionListeners.erase(std::find(mesgDefinitionListeners.begin(), mesgDefinitionListeners.end(), &mesgDefinitionListener)); +} + +void MesgBroadcaster::AddListener(MesgListener& mesgListener) +{ + mesgListeners.push_back(&mesgListener); +} + +void MesgBroadcaster::RemoveListener(MesgListener& mesgListener) +{ + mesgListeners.erase(std::find(mesgListeners.begin(), mesgListeners.end(), &mesgListener)); +} + +void MesgBroadcaster::AddListener(MesgWithEventListener& mesgListener) +{ + mesgWithEventBroadcaster.AddListener(mesgListener); +} + +void MesgBroadcaster::RemoveListener(MesgWithEventListener& mesgListener) +{ + mesgWithEventBroadcaster.RemoveListener(mesgListener); +} + +void MesgBroadcaster::AddListener(BufferedRecordMesgListener& bufferedRecordMesgListener) +{ + bufferedRecordMesgBroadcaster.AddListener(bufferedRecordMesgListener); +} + +void MesgBroadcaster::RemoveListener(BufferedRecordMesgListener& bufferedRecordMesgListener) +{ + bufferedRecordMesgBroadcaster.RemoveListener(bufferedRecordMesgListener); +} + +void MesgBroadcaster::AddListener(FileIdMesgListener& fileIdMesgListener) +{ + fileIdMesgListeners.push_back(&fileIdMesgListener); +} + +void MesgBroadcaster::RemoveListener(FileIdMesgListener& fileIdMesgListener) +{ + std::vector::iterator it = std::find(fileIdMesgListeners.begin(), fileIdMesgListeners.end(), &fileIdMesgListener); + if (fileIdMesgListeners.end() != it) + fileIdMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(FileCreatorMesgListener& fileCreatorMesgListener) +{ + fileCreatorMesgListeners.push_back(&fileCreatorMesgListener); +} + +void MesgBroadcaster::RemoveListener(FileCreatorMesgListener& fileCreatorMesgListener) +{ + std::vector::iterator it = std::find(fileCreatorMesgListeners.begin(), fileCreatorMesgListeners.end(), &fileCreatorMesgListener); + if (fileCreatorMesgListeners.end() != it) + fileCreatorMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TimestampCorrelationMesgListener& timestampCorrelationMesgListener) +{ + timestampCorrelationMesgListeners.push_back(×tampCorrelationMesgListener); +} + +void MesgBroadcaster::RemoveListener(TimestampCorrelationMesgListener& timestampCorrelationMesgListener) +{ + std::vector::iterator it = std::find(timestampCorrelationMesgListeners.begin(), timestampCorrelationMesgListeners.end(), ×tampCorrelationMesgListener); + if (timestampCorrelationMesgListeners.end() != it) + timestampCorrelationMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SoftwareMesgListener& softwareMesgListener) +{ + softwareMesgListeners.push_back(&softwareMesgListener); +} + +void MesgBroadcaster::RemoveListener(SoftwareMesgListener& softwareMesgListener) +{ + std::vector::iterator it = std::find(softwareMesgListeners.begin(), softwareMesgListeners.end(), &softwareMesgListener); + if (softwareMesgListeners.end() != it) + softwareMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SlaveDeviceMesgListener& slaveDeviceMesgListener) +{ + slaveDeviceMesgListeners.push_back(&slaveDeviceMesgListener); +} + +void MesgBroadcaster::RemoveListener(SlaveDeviceMesgListener& slaveDeviceMesgListener) +{ + std::vector::iterator it = std::find(slaveDeviceMesgListeners.begin(), slaveDeviceMesgListeners.end(), &slaveDeviceMesgListener); + if (slaveDeviceMesgListeners.end() != it) + slaveDeviceMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(CapabilitiesMesgListener& capabilitiesMesgListener) +{ + capabilitiesMesgListeners.push_back(&capabilitiesMesgListener); +} + +void MesgBroadcaster::RemoveListener(CapabilitiesMesgListener& capabilitiesMesgListener) +{ + std::vector::iterator it = std::find(capabilitiesMesgListeners.begin(), capabilitiesMesgListeners.end(), &capabilitiesMesgListener); + if (capabilitiesMesgListeners.end() != it) + capabilitiesMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(FileCapabilitiesMesgListener& fileCapabilitiesMesgListener) +{ + fileCapabilitiesMesgListeners.push_back(&fileCapabilitiesMesgListener); +} + +void MesgBroadcaster::RemoveListener(FileCapabilitiesMesgListener& fileCapabilitiesMesgListener) +{ + std::vector::iterator it = std::find(fileCapabilitiesMesgListeners.begin(), fileCapabilitiesMesgListeners.end(), &fileCapabilitiesMesgListener); + if (fileCapabilitiesMesgListeners.end() != it) + fileCapabilitiesMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MesgCapabilitiesMesgListener& mesgCapabilitiesMesgListener) +{ + mesgCapabilitiesMesgListeners.push_back(&mesgCapabilitiesMesgListener); +} + +void MesgBroadcaster::RemoveListener(MesgCapabilitiesMesgListener& mesgCapabilitiesMesgListener) +{ + std::vector::iterator it = std::find(mesgCapabilitiesMesgListeners.begin(), mesgCapabilitiesMesgListeners.end(), &mesgCapabilitiesMesgListener); + if (mesgCapabilitiesMesgListeners.end() != it) + mesgCapabilitiesMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(FieldCapabilitiesMesgListener& fieldCapabilitiesMesgListener) +{ + fieldCapabilitiesMesgListeners.push_back(&fieldCapabilitiesMesgListener); +} + +void MesgBroadcaster::RemoveListener(FieldCapabilitiesMesgListener& fieldCapabilitiesMesgListener) +{ + std::vector::iterator it = std::find(fieldCapabilitiesMesgListeners.begin(), fieldCapabilitiesMesgListeners.end(), &fieldCapabilitiesMesgListener); + if (fieldCapabilitiesMesgListeners.end() != it) + fieldCapabilitiesMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DeviceSettingsMesgListener& deviceSettingsMesgListener) +{ + deviceSettingsMesgListeners.push_back(&deviceSettingsMesgListener); +} + +void MesgBroadcaster::RemoveListener(DeviceSettingsMesgListener& deviceSettingsMesgListener) +{ + std::vector::iterator it = std::find(deviceSettingsMesgListeners.begin(), deviceSettingsMesgListeners.end(), &deviceSettingsMesgListener); + if (deviceSettingsMesgListeners.end() != it) + deviceSettingsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(UserProfileMesgListener& userProfileMesgListener) +{ + userProfileMesgListeners.push_back(&userProfileMesgListener); +} + +void MesgBroadcaster::RemoveListener(UserProfileMesgListener& userProfileMesgListener) +{ + std::vector::iterator it = std::find(userProfileMesgListeners.begin(), userProfileMesgListeners.end(), &userProfileMesgListener); + if (userProfileMesgListeners.end() != it) + userProfileMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HrmProfileMesgListener& hrmProfileMesgListener) +{ + hrmProfileMesgListeners.push_back(&hrmProfileMesgListener); +} + +void MesgBroadcaster::RemoveListener(HrmProfileMesgListener& hrmProfileMesgListener) +{ + std::vector::iterator it = std::find(hrmProfileMesgListeners.begin(), hrmProfileMesgListeners.end(), &hrmProfileMesgListener); + if (hrmProfileMesgListeners.end() != it) + hrmProfileMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SdmProfileMesgListener& sdmProfileMesgListener) +{ + sdmProfileMesgListeners.push_back(&sdmProfileMesgListener); +} + +void MesgBroadcaster::RemoveListener(SdmProfileMesgListener& sdmProfileMesgListener) +{ + std::vector::iterator it = std::find(sdmProfileMesgListeners.begin(), sdmProfileMesgListeners.end(), &sdmProfileMesgListener); + if (sdmProfileMesgListeners.end() != it) + sdmProfileMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(BikeProfileMesgListener& bikeProfileMesgListener) +{ + bikeProfileMesgListeners.push_back(&bikeProfileMesgListener); +} + +void MesgBroadcaster::RemoveListener(BikeProfileMesgListener& bikeProfileMesgListener) +{ + std::vector::iterator it = std::find(bikeProfileMesgListeners.begin(), bikeProfileMesgListeners.end(), &bikeProfileMesgListener); + if (bikeProfileMesgListeners.end() != it) + bikeProfileMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ConnectivityMesgListener& connectivityMesgListener) +{ + connectivityMesgListeners.push_back(&connectivityMesgListener); +} + +void MesgBroadcaster::RemoveListener(ConnectivityMesgListener& connectivityMesgListener) +{ + std::vector::iterator it = std::find(connectivityMesgListeners.begin(), connectivityMesgListeners.end(), &connectivityMesgListener); + if (connectivityMesgListeners.end() != it) + connectivityMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WatchfaceSettingsMesgListener& watchfaceSettingsMesgListener) +{ + watchfaceSettingsMesgListeners.push_back(&watchfaceSettingsMesgListener); +} + +void MesgBroadcaster::RemoveListener(WatchfaceSettingsMesgListener& watchfaceSettingsMesgListener) +{ + std::vector::iterator it = std::find(watchfaceSettingsMesgListeners.begin(), watchfaceSettingsMesgListeners.end(), &watchfaceSettingsMesgListener); + if (watchfaceSettingsMesgListeners.end() != it) + watchfaceSettingsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(OhrSettingsMesgListener& ohrSettingsMesgListener) +{ + ohrSettingsMesgListeners.push_back(&ohrSettingsMesgListener); +} + +void MesgBroadcaster::RemoveListener(OhrSettingsMesgListener& ohrSettingsMesgListener) +{ + std::vector::iterator it = std::find(ohrSettingsMesgListeners.begin(), ohrSettingsMesgListeners.end(), &ohrSettingsMesgListener); + if (ohrSettingsMesgListeners.end() != it) + ohrSettingsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TimeInZoneMesgListener& timeInZoneMesgListener) +{ + timeInZoneMesgListeners.push_back(&timeInZoneMesgListener); +} + +void MesgBroadcaster::RemoveListener(TimeInZoneMesgListener& timeInZoneMesgListener) +{ + std::vector::iterator it = std::find(timeInZoneMesgListeners.begin(), timeInZoneMesgListeners.end(), &timeInZoneMesgListener); + if (timeInZoneMesgListeners.end() != it) + timeInZoneMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ZonesTargetMesgListener& zonesTargetMesgListener) +{ + zonesTargetMesgListeners.push_back(&zonesTargetMesgListener); +} + +void MesgBroadcaster::RemoveListener(ZonesTargetMesgListener& zonesTargetMesgListener) +{ + std::vector::iterator it = std::find(zonesTargetMesgListeners.begin(), zonesTargetMesgListeners.end(), &zonesTargetMesgListener); + if (zonesTargetMesgListeners.end() != it) + zonesTargetMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SportMesgListener& sportMesgListener) +{ + sportMesgListeners.push_back(&sportMesgListener); +} + +void MesgBroadcaster::RemoveListener(SportMesgListener& sportMesgListener) +{ + std::vector::iterator it = std::find(sportMesgListeners.begin(), sportMesgListeners.end(), &sportMesgListener); + if (sportMesgListeners.end() != it) + sportMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HrZoneMesgListener& hrZoneMesgListener) +{ + hrZoneMesgListeners.push_back(&hrZoneMesgListener); +} + +void MesgBroadcaster::RemoveListener(HrZoneMesgListener& hrZoneMesgListener) +{ + std::vector::iterator it = std::find(hrZoneMesgListeners.begin(), hrZoneMesgListeners.end(), &hrZoneMesgListener); + if (hrZoneMesgListeners.end() != it) + hrZoneMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SpeedZoneMesgListener& speedZoneMesgListener) +{ + speedZoneMesgListeners.push_back(&speedZoneMesgListener); +} + +void MesgBroadcaster::RemoveListener(SpeedZoneMesgListener& speedZoneMesgListener) +{ + std::vector::iterator it = std::find(speedZoneMesgListeners.begin(), speedZoneMesgListeners.end(), &speedZoneMesgListener); + if (speedZoneMesgListeners.end() != it) + speedZoneMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(CadenceZoneMesgListener& cadenceZoneMesgListener) +{ + cadenceZoneMesgListeners.push_back(&cadenceZoneMesgListener); +} + +void MesgBroadcaster::RemoveListener(CadenceZoneMesgListener& cadenceZoneMesgListener) +{ + std::vector::iterator it = std::find(cadenceZoneMesgListeners.begin(), cadenceZoneMesgListeners.end(), &cadenceZoneMesgListener); + if (cadenceZoneMesgListeners.end() != it) + cadenceZoneMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(PowerZoneMesgListener& powerZoneMesgListener) +{ + powerZoneMesgListeners.push_back(&powerZoneMesgListener); +} + +void MesgBroadcaster::RemoveListener(PowerZoneMesgListener& powerZoneMesgListener) +{ + std::vector::iterator it = std::find(powerZoneMesgListeners.begin(), powerZoneMesgListeners.end(), &powerZoneMesgListener); + if (powerZoneMesgListeners.end() != it) + powerZoneMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MetZoneMesgListener& metZoneMesgListener) +{ + metZoneMesgListeners.push_back(&metZoneMesgListener); +} + +void MesgBroadcaster::RemoveListener(MetZoneMesgListener& metZoneMesgListener) +{ + std::vector::iterator it = std::find(metZoneMesgListeners.begin(), metZoneMesgListeners.end(), &metZoneMesgListener); + if (metZoneMesgListeners.end() != it) + metZoneMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TrainingSettingsMesgListener& trainingSettingsMesgListener) +{ + trainingSettingsMesgListeners.push_back(&trainingSettingsMesgListener); +} + +void MesgBroadcaster::RemoveListener(TrainingSettingsMesgListener& trainingSettingsMesgListener) +{ + std::vector::iterator it = std::find(trainingSettingsMesgListeners.begin(), trainingSettingsMesgListeners.end(), &trainingSettingsMesgListener); + if (trainingSettingsMesgListeners.end() != it) + trainingSettingsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DiveSettingsMesgListener& diveSettingsMesgListener) +{ + diveSettingsMesgListeners.push_back(&diveSettingsMesgListener); +} + +void MesgBroadcaster::RemoveListener(DiveSettingsMesgListener& diveSettingsMesgListener) +{ + std::vector::iterator it = std::find(diveSettingsMesgListeners.begin(), diveSettingsMesgListeners.end(), &diveSettingsMesgListener); + if (diveSettingsMesgListeners.end() != it) + diveSettingsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DiveAlarmMesgListener& diveAlarmMesgListener) +{ + diveAlarmMesgListeners.push_back(&diveAlarmMesgListener); +} + +void MesgBroadcaster::RemoveListener(DiveAlarmMesgListener& diveAlarmMesgListener) +{ + std::vector::iterator it = std::find(diveAlarmMesgListeners.begin(), diveAlarmMesgListeners.end(), &diveAlarmMesgListener); + if (diveAlarmMesgListeners.end() != it) + diveAlarmMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DiveApneaAlarmMesgListener& diveApneaAlarmMesgListener) +{ + diveApneaAlarmMesgListeners.push_back(&diveApneaAlarmMesgListener); +} + +void MesgBroadcaster::RemoveListener(DiveApneaAlarmMesgListener& diveApneaAlarmMesgListener) +{ + std::vector::iterator it = std::find(diveApneaAlarmMesgListeners.begin(), diveApneaAlarmMesgListeners.end(), &diveApneaAlarmMesgListener); + if (diveApneaAlarmMesgListeners.end() != it) + diveApneaAlarmMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DiveGasMesgListener& diveGasMesgListener) +{ + diveGasMesgListeners.push_back(&diveGasMesgListener); +} + +void MesgBroadcaster::RemoveListener(DiveGasMesgListener& diveGasMesgListener) +{ + std::vector::iterator it = std::find(diveGasMesgListeners.begin(), diveGasMesgListeners.end(), &diveGasMesgListener); + if (diveGasMesgListeners.end() != it) + diveGasMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(GoalMesgListener& goalMesgListener) +{ + goalMesgListeners.push_back(&goalMesgListener); +} + +void MesgBroadcaster::RemoveListener(GoalMesgListener& goalMesgListener) +{ + std::vector::iterator it = std::find(goalMesgListeners.begin(), goalMesgListeners.end(), &goalMesgListener); + if (goalMesgListeners.end() != it) + goalMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ActivityMesgListener& activityMesgListener) +{ + activityMesgListeners.push_back(&activityMesgListener); +} + +void MesgBroadcaster::RemoveListener(ActivityMesgListener& activityMesgListener) +{ + std::vector::iterator it = std::find(activityMesgListeners.begin(), activityMesgListeners.end(), &activityMesgListener); + if (activityMesgListeners.end() != it) + activityMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SessionMesgListener& sessionMesgListener) +{ + sessionMesgListeners.push_back(&sessionMesgListener); +} + +void MesgBroadcaster::RemoveListener(SessionMesgListener& sessionMesgListener) +{ + std::vector::iterator it = std::find(sessionMesgListeners.begin(), sessionMesgListeners.end(), &sessionMesgListener); + if (sessionMesgListeners.end() != it) + sessionMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(LapMesgListener& lapMesgListener) +{ + lapMesgListeners.push_back(&lapMesgListener); +} + +void MesgBroadcaster::RemoveListener(LapMesgListener& lapMesgListener) +{ + std::vector::iterator it = std::find(lapMesgListeners.begin(), lapMesgListeners.end(), &lapMesgListener); + if (lapMesgListeners.end() != it) + lapMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(LengthMesgListener& lengthMesgListener) +{ + lengthMesgListeners.push_back(&lengthMesgListener); +} + +void MesgBroadcaster::RemoveListener(LengthMesgListener& lengthMesgListener) +{ + std::vector::iterator it = std::find(lengthMesgListeners.begin(), lengthMesgListeners.end(), &lengthMesgListener); + if (lengthMesgListeners.end() != it) + lengthMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(RecordMesgListener& recordMesgListener) +{ + recordMesgListeners.push_back(&recordMesgListener); +} + +void MesgBroadcaster::RemoveListener(RecordMesgListener& recordMesgListener) +{ + std::vector::iterator it = std::find(recordMesgListeners.begin(), recordMesgListeners.end(), &recordMesgListener); + if (recordMesgListeners.end() != it) + recordMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(EventMesgListener& eventMesgListener) +{ + eventMesgListeners.push_back(&eventMesgListener); +} + +void MesgBroadcaster::RemoveListener(EventMesgListener& eventMesgListener) +{ + std::vector::iterator it = std::find(eventMesgListeners.begin(), eventMesgListeners.end(), &eventMesgListener); + if (eventMesgListeners.end() != it) + eventMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DeviceInfoMesgListener& deviceInfoMesgListener) +{ + deviceInfoMesgListeners.push_back(&deviceInfoMesgListener); +} + +void MesgBroadcaster::RemoveListener(DeviceInfoMesgListener& deviceInfoMesgListener) +{ + std::vector::iterator it = std::find(deviceInfoMesgListeners.begin(), deviceInfoMesgListeners.end(), &deviceInfoMesgListener); + if (deviceInfoMesgListeners.end() != it) + deviceInfoMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DeviceAuxBatteryInfoMesgListener& deviceAuxBatteryInfoMesgListener) +{ + deviceAuxBatteryInfoMesgListeners.push_back(&deviceAuxBatteryInfoMesgListener); +} + +void MesgBroadcaster::RemoveListener(DeviceAuxBatteryInfoMesgListener& deviceAuxBatteryInfoMesgListener) +{ + std::vector::iterator it = std::find(deviceAuxBatteryInfoMesgListeners.begin(), deviceAuxBatteryInfoMesgListeners.end(), &deviceAuxBatteryInfoMesgListener); + if (deviceAuxBatteryInfoMesgListeners.end() != it) + deviceAuxBatteryInfoMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TrainingFileMesgListener& trainingFileMesgListener) +{ + trainingFileMesgListeners.push_back(&trainingFileMesgListener); +} + +void MesgBroadcaster::RemoveListener(TrainingFileMesgListener& trainingFileMesgListener) +{ + std::vector::iterator it = std::find(trainingFileMesgListeners.begin(), trainingFileMesgListeners.end(), &trainingFileMesgListener); + if (trainingFileMesgListeners.end() != it) + trainingFileMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WeatherConditionsMesgListener& weatherConditionsMesgListener) +{ + weatherConditionsMesgListeners.push_back(&weatherConditionsMesgListener); +} + +void MesgBroadcaster::RemoveListener(WeatherConditionsMesgListener& weatherConditionsMesgListener) +{ + std::vector::iterator it = std::find(weatherConditionsMesgListeners.begin(), weatherConditionsMesgListeners.end(), &weatherConditionsMesgListener); + if (weatherConditionsMesgListeners.end() != it) + weatherConditionsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WeatherAlertMesgListener& weatherAlertMesgListener) +{ + weatherAlertMesgListeners.push_back(&weatherAlertMesgListener); +} + +void MesgBroadcaster::RemoveListener(WeatherAlertMesgListener& weatherAlertMesgListener) +{ + std::vector::iterator it = std::find(weatherAlertMesgListeners.begin(), weatherAlertMesgListeners.end(), &weatherAlertMesgListener); + if (weatherAlertMesgListeners.end() != it) + weatherAlertMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(GpsMetadataMesgListener& gpsMetadataMesgListener) +{ + gpsMetadataMesgListeners.push_back(&gpsMetadataMesgListener); +} + +void MesgBroadcaster::RemoveListener(GpsMetadataMesgListener& gpsMetadataMesgListener) +{ + std::vector::iterator it = std::find(gpsMetadataMesgListeners.begin(), gpsMetadataMesgListeners.end(), &gpsMetadataMesgListener); + if (gpsMetadataMesgListeners.end() != it) + gpsMetadataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(CameraEventMesgListener& cameraEventMesgListener) +{ + cameraEventMesgListeners.push_back(&cameraEventMesgListener); +} + +void MesgBroadcaster::RemoveListener(CameraEventMesgListener& cameraEventMesgListener) +{ + std::vector::iterator it = std::find(cameraEventMesgListeners.begin(), cameraEventMesgListeners.end(), &cameraEventMesgListener); + if (cameraEventMesgListeners.end() != it) + cameraEventMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(GyroscopeDataMesgListener& gyroscopeDataMesgListener) +{ + gyroscopeDataMesgListeners.push_back(&gyroscopeDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(GyroscopeDataMesgListener& gyroscopeDataMesgListener) +{ + std::vector::iterator it = std::find(gyroscopeDataMesgListeners.begin(), gyroscopeDataMesgListeners.end(), &gyroscopeDataMesgListener); + if (gyroscopeDataMesgListeners.end() != it) + gyroscopeDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(AccelerometerDataMesgListener& accelerometerDataMesgListener) +{ + accelerometerDataMesgListeners.push_back(&accelerometerDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(AccelerometerDataMesgListener& accelerometerDataMesgListener) +{ + std::vector::iterator it = std::find(accelerometerDataMesgListeners.begin(), accelerometerDataMesgListeners.end(), &accelerometerDataMesgListener); + if (accelerometerDataMesgListeners.end() != it) + accelerometerDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MagnetometerDataMesgListener& magnetometerDataMesgListener) +{ + magnetometerDataMesgListeners.push_back(&magnetometerDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(MagnetometerDataMesgListener& magnetometerDataMesgListener) +{ + std::vector::iterator it = std::find(magnetometerDataMesgListeners.begin(), magnetometerDataMesgListeners.end(), &magnetometerDataMesgListener); + if (magnetometerDataMesgListeners.end() != it) + magnetometerDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(BarometerDataMesgListener& barometerDataMesgListener) +{ + barometerDataMesgListeners.push_back(&barometerDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(BarometerDataMesgListener& barometerDataMesgListener) +{ + std::vector::iterator it = std::find(barometerDataMesgListeners.begin(), barometerDataMesgListeners.end(), &barometerDataMesgListener); + if (barometerDataMesgListeners.end() != it) + barometerDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ThreeDSensorCalibrationMesgListener& threeDSensorCalibrationMesgListener) +{ + threeDSensorCalibrationMesgListeners.push_back(&threeDSensorCalibrationMesgListener); +} + +void MesgBroadcaster::RemoveListener(ThreeDSensorCalibrationMesgListener& threeDSensorCalibrationMesgListener) +{ + std::vector::iterator it = std::find(threeDSensorCalibrationMesgListeners.begin(), threeDSensorCalibrationMesgListeners.end(), &threeDSensorCalibrationMesgListener); + if (threeDSensorCalibrationMesgListeners.end() != it) + threeDSensorCalibrationMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(OneDSensorCalibrationMesgListener& oneDSensorCalibrationMesgListener) +{ + oneDSensorCalibrationMesgListeners.push_back(&oneDSensorCalibrationMesgListener); +} + +void MesgBroadcaster::RemoveListener(OneDSensorCalibrationMesgListener& oneDSensorCalibrationMesgListener) +{ + std::vector::iterator it = std::find(oneDSensorCalibrationMesgListeners.begin(), oneDSensorCalibrationMesgListeners.end(), &oneDSensorCalibrationMesgListener); + if (oneDSensorCalibrationMesgListeners.end() != it) + oneDSensorCalibrationMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(VideoFrameMesgListener& videoFrameMesgListener) +{ + videoFrameMesgListeners.push_back(&videoFrameMesgListener); +} + +void MesgBroadcaster::RemoveListener(VideoFrameMesgListener& videoFrameMesgListener) +{ + std::vector::iterator it = std::find(videoFrameMesgListeners.begin(), videoFrameMesgListeners.end(), &videoFrameMesgListener); + if (videoFrameMesgListeners.end() != it) + videoFrameMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ObdiiDataMesgListener& obdiiDataMesgListener) +{ + obdiiDataMesgListeners.push_back(&obdiiDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(ObdiiDataMesgListener& obdiiDataMesgListener) +{ + std::vector::iterator it = std::find(obdiiDataMesgListeners.begin(), obdiiDataMesgListeners.end(), &obdiiDataMesgListener); + if (obdiiDataMesgListeners.end() != it) + obdiiDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(NmeaSentenceMesgListener& nmeaSentenceMesgListener) +{ + nmeaSentenceMesgListeners.push_back(&nmeaSentenceMesgListener); +} + +void MesgBroadcaster::RemoveListener(NmeaSentenceMesgListener& nmeaSentenceMesgListener) +{ + std::vector::iterator it = std::find(nmeaSentenceMesgListeners.begin(), nmeaSentenceMesgListeners.end(), &nmeaSentenceMesgListener); + if (nmeaSentenceMesgListeners.end() != it) + nmeaSentenceMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(AviationAttitudeMesgListener& aviationAttitudeMesgListener) +{ + aviationAttitudeMesgListeners.push_back(&aviationAttitudeMesgListener); +} + +void MesgBroadcaster::RemoveListener(AviationAttitudeMesgListener& aviationAttitudeMesgListener) +{ + std::vector::iterator it = std::find(aviationAttitudeMesgListeners.begin(), aviationAttitudeMesgListeners.end(), &aviationAttitudeMesgListener); + if (aviationAttitudeMesgListeners.end() != it) + aviationAttitudeMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(VideoMesgListener& videoMesgListener) +{ + videoMesgListeners.push_back(&videoMesgListener); +} + +void MesgBroadcaster::RemoveListener(VideoMesgListener& videoMesgListener) +{ + std::vector::iterator it = std::find(videoMesgListeners.begin(), videoMesgListeners.end(), &videoMesgListener); + if (videoMesgListeners.end() != it) + videoMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(VideoTitleMesgListener& videoTitleMesgListener) +{ + videoTitleMesgListeners.push_back(&videoTitleMesgListener); +} + +void MesgBroadcaster::RemoveListener(VideoTitleMesgListener& videoTitleMesgListener) +{ + std::vector::iterator it = std::find(videoTitleMesgListeners.begin(), videoTitleMesgListeners.end(), &videoTitleMesgListener); + if (videoTitleMesgListeners.end() != it) + videoTitleMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(VideoDescriptionMesgListener& videoDescriptionMesgListener) +{ + videoDescriptionMesgListeners.push_back(&videoDescriptionMesgListener); +} + +void MesgBroadcaster::RemoveListener(VideoDescriptionMesgListener& videoDescriptionMesgListener) +{ + std::vector::iterator it = std::find(videoDescriptionMesgListeners.begin(), videoDescriptionMesgListeners.end(), &videoDescriptionMesgListener); + if (videoDescriptionMesgListeners.end() != it) + videoDescriptionMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(VideoClipMesgListener& videoClipMesgListener) +{ + videoClipMesgListeners.push_back(&videoClipMesgListener); +} + +void MesgBroadcaster::RemoveListener(VideoClipMesgListener& videoClipMesgListener) +{ + std::vector::iterator it = std::find(videoClipMesgListeners.begin(), videoClipMesgListeners.end(), &videoClipMesgListener); + if (videoClipMesgListeners.end() != it) + videoClipMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SetMesgListener& setMesgListener) +{ + setMesgListeners.push_back(&setMesgListener); +} + +void MesgBroadcaster::RemoveListener(SetMesgListener& setMesgListener) +{ + std::vector::iterator it = std::find(setMesgListeners.begin(), setMesgListeners.end(), &setMesgListener); + if (setMesgListeners.end() != it) + setMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(JumpMesgListener& jumpMesgListener) +{ + jumpMesgListeners.push_back(&jumpMesgListener); +} + +void MesgBroadcaster::RemoveListener(JumpMesgListener& jumpMesgListener) +{ + std::vector::iterator it = std::find(jumpMesgListeners.begin(), jumpMesgListeners.end(), &jumpMesgListener); + if (jumpMesgListeners.end() != it) + jumpMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SplitMesgListener& splitMesgListener) +{ + splitMesgListeners.push_back(&splitMesgListener); +} + +void MesgBroadcaster::RemoveListener(SplitMesgListener& splitMesgListener) +{ + std::vector::iterator it = std::find(splitMesgListeners.begin(), splitMesgListeners.end(), &splitMesgListener); + if (splitMesgListeners.end() != it) + splitMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SplitSummaryMesgListener& splitSummaryMesgListener) +{ + splitSummaryMesgListeners.push_back(&splitSummaryMesgListener); +} + +void MesgBroadcaster::RemoveListener(SplitSummaryMesgListener& splitSummaryMesgListener) +{ + std::vector::iterator it = std::find(splitSummaryMesgListeners.begin(), splitSummaryMesgListeners.end(), &splitSummaryMesgListener); + if (splitSummaryMesgListeners.end() != it) + splitSummaryMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ClimbProMesgListener& climbProMesgListener) +{ + climbProMesgListeners.push_back(&climbProMesgListener); +} + +void MesgBroadcaster::RemoveListener(ClimbProMesgListener& climbProMesgListener) +{ + std::vector::iterator it = std::find(climbProMesgListeners.begin(), climbProMesgListeners.end(), &climbProMesgListener); + if (climbProMesgListeners.end() != it) + climbProMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(FieldDescriptionMesgListener& fieldDescriptionMesgListener) +{ + fieldDescriptionMesgListeners.push_back(&fieldDescriptionMesgListener); +} + +void MesgBroadcaster::RemoveListener(FieldDescriptionMesgListener& fieldDescriptionMesgListener) +{ + std::vector::iterator it = std::find(fieldDescriptionMesgListeners.begin(), fieldDescriptionMesgListeners.end(), &fieldDescriptionMesgListener); + if (fieldDescriptionMesgListeners.end() != it) + fieldDescriptionMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DeveloperDataIdMesgListener& developerDataIdMesgListener) +{ + developerDataIdMesgListeners.push_back(&developerDataIdMesgListener); +} + +void MesgBroadcaster::RemoveListener(DeveloperDataIdMesgListener& developerDataIdMesgListener) +{ + std::vector::iterator it = std::find(developerDataIdMesgListeners.begin(), developerDataIdMesgListeners.end(), &developerDataIdMesgListener); + if (developerDataIdMesgListeners.end() != it) + developerDataIdMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(CourseMesgListener& courseMesgListener) +{ + courseMesgListeners.push_back(&courseMesgListener); +} + +void MesgBroadcaster::RemoveListener(CourseMesgListener& courseMesgListener) +{ + std::vector::iterator it = std::find(courseMesgListeners.begin(), courseMesgListeners.end(), &courseMesgListener); + if (courseMesgListeners.end() != it) + courseMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(CoursePointMesgListener& coursePointMesgListener) +{ + coursePointMesgListeners.push_back(&coursePointMesgListener); +} + +void MesgBroadcaster::RemoveListener(CoursePointMesgListener& coursePointMesgListener) +{ + std::vector::iterator it = std::find(coursePointMesgListeners.begin(), coursePointMesgListeners.end(), &coursePointMesgListener); + if (coursePointMesgListeners.end() != it) + coursePointMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SegmentIdMesgListener& segmentIdMesgListener) +{ + segmentIdMesgListeners.push_back(&segmentIdMesgListener); +} + +void MesgBroadcaster::RemoveListener(SegmentIdMesgListener& segmentIdMesgListener) +{ + std::vector::iterator it = std::find(segmentIdMesgListeners.begin(), segmentIdMesgListeners.end(), &segmentIdMesgListener); + if (segmentIdMesgListeners.end() != it) + segmentIdMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SegmentLeaderboardEntryMesgListener& segmentLeaderboardEntryMesgListener) +{ + segmentLeaderboardEntryMesgListeners.push_back(&segmentLeaderboardEntryMesgListener); +} + +void MesgBroadcaster::RemoveListener(SegmentLeaderboardEntryMesgListener& segmentLeaderboardEntryMesgListener) +{ + std::vector::iterator it = std::find(segmentLeaderboardEntryMesgListeners.begin(), segmentLeaderboardEntryMesgListeners.end(), &segmentLeaderboardEntryMesgListener); + if (segmentLeaderboardEntryMesgListeners.end() != it) + segmentLeaderboardEntryMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SegmentPointMesgListener& segmentPointMesgListener) +{ + segmentPointMesgListeners.push_back(&segmentPointMesgListener); +} + +void MesgBroadcaster::RemoveListener(SegmentPointMesgListener& segmentPointMesgListener) +{ + std::vector::iterator it = std::find(segmentPointMesgListeners.begin(), segmentPointMesgListeners.end(), &segmentPointMesgListener); + if (segmentPointMesgListeners.end() != it) + segmentPointMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SegmentLapMesgListener& segmentLapMesgListener) +{ + segmentLapMesgListeners.push_back(&segmentLapMesgListener); +} + +void MesgBroadcaster::RemoveListener(SegmentLapMesgListener& segmentLapMesgListener) +{ + std::vector::iterator it = std::find(segmentLapMesgListeners.begin(), segmentLapMesgListeners.end(), &segmentLapMesgListener); + if (segmentLapMesgListeners.end() != it) + segmentLapMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SegmentFileMesgListener& segmentFileMesgListener) +{ + segmentFileMesgListeners.push_back(&segmentFileMesgListener); +} + +void MesgBroadcaster::RemoveListener(SegmentFileMesgListener& segmentFileMesgListener) +{ + std::vector::iterator it = std::find(segmentFileMesgListeners.begin(), segmentFileMesgListeners.end(), &segmentFileMesgListener); + if (segmentFileMesgListeners.end() != it) + segmentFileMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WorkoutMesgListener& workoutMesgListener) +{ + workoutMesgListeners.push_back(&workoutMesgListener); +} + +void MesgBroadcaster::RemoveListener(WorkoutMesgListener& workoutMesgListener) +{ + std::vector::iterator it = std::find(workoutMesgListeners.begin(), workoutMesgListeners.end(), &workoutMesgListener); + if (workoutMesgListeners.end() != it) + workoutMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WorkoutSessionMesgListener& workoutSessionMesgListener) +{ + workoutSessionMesgListeners.push_back(&workoutSessionMesgListener); +} + +void MesgBroadcaster::RemoveListener(WorkoutSessionMesgListener& workoutSessionMesgListener) +{ + std::vector::iterator it = std::find(workoutSessionMesgListeners.begin(), workoutSessionMesgListeners.end(), &workoutSessionMesgListener); + if (workoutSessionMesgListeners.end() != it) + workoutSessionMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WorkoutStepMesgListener& workoutStepMesgListener) +{ + workoutStepMesgListeners.push_back(&workoutStepMesgListener); +} + +void MesgBroadcaster::RemoveListener(WorkoutStepMesgListener& workoutStepMesgListener) +{ + std::vector::iterator it = std::find(workoutStepMesgListeners.begin(), workoutStepMesgListeners.end(), &workoutStepMesgListener); + if (workoutStepMesgListeners.end() != it) + workoutStepMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ExerciseTitleMesgListener& exerciseTitleMesgListener) +{ + exerciseTitleMesgListeners.push_back(&exerciseTitleMesgListener); +} + +void MesgBroadcaster::RemoveListener(ExerciseTitleMesgListener& exerciseTitleMesgListener) +{ + std::vector::iterator it = std::find(exerciseTitleMesgListeners.begin(), exerciseTitleMesgListeners.end(), &exerciseTitleMesgListener); + if (exerciseTitleMesgListeners.end() != it) + exerciseTitleMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ScheduleMesgListener& scheduleMesgListener) +{ + scheduleMesgListeners.push_back(&scheduleMesgListener); +} + +void MesgBroadcaster::RemoveListener(ScheduleMesgListener& scheduleMesgListener) +{ + std::vector::iterator it = std::find(scheduleMesgListeners.begin(), scheduleMesgListeners.end(), &scheduleMesgListener); + if (scheduleMesgListeners.end() != it) + scheduleMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TotalsMesgListener& totalsMesgListener) +{ + totalsMesgListeners.push_back(&totalsMesgListener); +} + +void MesgBroadcaster::RemoveListener(TotalsMesgListener& totalsMesgListener) +{ + std::vector::iterator it = std::find(totalsMesgListeners.begin(), totalsMesgListeners.end(), &totalsMesgListener); + if (totalsMesgListeners.end() != it) + totalsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(WeightScaleMesgListener& weightScaleMesgListener) +{ + weightScaleMesgListeners.push_back(&weightScaleMesgListener); +} + +void MesgBroadcaster::RemoveListener(WeightScaleMesgListener& weightScaleMesgListener) +{ + std::vector::iterator it = std::find(weightScaleMesgListeners.begin(), weightScaleMesgListeners.end(), &weightScaleMesgListener); + if (weightScaleMesgListeners.end() != it) + weightScaleMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(BloodPressureMesgListener& bloodPressureMesgListener) +{ + bloodPressureMesgListeners.push_back(&bloodPressureMesgListener); +} + +void MesgBroadcaster::RemoveListener(BloodPressureMesgListener& bloodPressureMesgListener) +{ + std::vector::iterator it = std::find(bloodPressureMesgListeners.begin(), bloodPressureMesgListeners.end(), &bloodPressureMesgListener); + if (bloodPressureMesgListeners.end() != it) + bloodPressureMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MonitoringInfoMesgListener& monitoringInfoMesgListener) +{ + monitoringInfoMesgListeners.push_back(&monitoringInfoMesgListener); +} + +void MesgBroadcaster::RemoveListener(MonitoringInfoMesgListener& monitoringInfoMesgListener) +{ + std::vector::iterator it = std::find(monitoringInfoMesgListeners.begin(), monitoringInfoMesgListeners.end(), &monitoringInfoMesgListener); + if (monitoringInfoMesgListeners.end() != it) + monitoringInfoMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MonitoringMesgListener& monitoringMesgListener) +{ + monitoringMesgListeners.push_back(&monitoringMesgListener); +} + +void MesgBroadcaster::RemoveListener(MonitoringMesgListener& monitoringMesgListener) +{ + std::vector::iterator it = std::find(monitoringMesgListeners.begin(), monitoringMesgListeners.end(), &monitoringMesgListener); + if (monitoringMesgListeners.end() != it) + monitoringMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MonitoringHrDataMesgListener& monitoringHrDataMesgListener) +{ + monitoringHrDataMesgListeners.push_back(&monitoringHrDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(MonitoringHrDataMesgListener& monitoringHrDataMesgListener) +{ + std::vector::iterator it = std::find(monitoringHrDataMesgListeners.begin(), monitoringHrDataMesgListeners.end(), &monitoringHrDataMesgListener); + if (monitoringHrDataMesgListeners.end() != it) + monitoringHrDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(Spo2DataMesgListener& spo2DataMesgListener) +{ + spo2DataMesgListeners.push_back(&spo2DataMesgListener); +} + +void MesgBroadcaster::RemoveListener(Spo2DataMesgListener& spo2DataMesgListener) +{ + std::vector::iterator it = std::find(spo2DataMesgListeners.begin(), spo2DataMesgListeners.end(), &spo2DataMesgListener); + if (spo2DataMesgListeners.end() != it) + spo2DataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HrMesgListener& hrMesgListener) +{ + hrMesgListeners.push_back(&hrMesgListener); +} + +void MesgBroadcaster::RemoveListener(HrMesgListener& hrMesgListener) +{ + std::vector::iterator it = std::find(hrMesgListeners.begin(), hrMesgListeners.end(), &hrMesgListener); + if (hrMesgListeners.end() != it) + hrMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(StressLevelMesgListener& stressLevelMesgListener) +{ + stressLevelMesgListeners.push_back(&stressLevelMesgListener); +} + +void MesgBroadcaster::RemoveListener(StressLevelMesgListener& stressLevelMesgListener) +{ + std::vector::iterator it = std::find(stressLevelMesgListeners.begin(), stressLevelMesgListeners.end(), &stressLevelMesgListener); + if (stressLevelMesgListeners.end() != it) + stressLevelMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MaxMetDataMesgListener& maxMetDataMesgListener) +{ + maxMetDataMesgListeners.push_back(&maxMetDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(MaxMetDataMesgListener& maxMetDataMesgListener) +{ + std::vector::iterator it = std::find(maxMetDataMesgListeners.begin(), maxMetDataMesgListeners.end(), &maxMetDataMesgListener); + if (maxMetDataMesgListeners.end() != it) + maxMetDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaBodyBatteryDataMesgListener& hsaBodyBatteryDataMesgListener) +{ + hsaBodyBatteryDataMesgListeners.push_back(&hsaBodyBatteryDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaBodyBatteryDataMesgListener& hsaBodyBatteryDataMesgListener) +{ + std::vector::iterator it = std::find(hsaBodyBatteryDataMesgListeners.begin(), hsaBodyBatteryDataMesgListeners.end(), &hsaBodyBatteryDataMesgListener); + if (hsaBodyBatteryDataMesgListeners.end() != it) + hsaBodyBatteryDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaEventMesgListener& hsaEventMesgListener) +{ + hsaEventMesgListeners.push_back(&hsaEventMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaEventMesgListener& hsaEventMesgListener) +{ + std::vector::iterator it = std::find(hsaEventMesgListeners.begin(), hsaEventMesgListeners.end(), &hsaEventMesgListener); + if (hsaEventMesgListeners.end() != it) + hsaEventMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaAccelerometerDataMesgListener& hsaAccelerometerDataMesgListener) +{ + hsaAccelerometerDataMesgListeners.push_back(&hsaAccelerometerDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaAccelerometerDataMesgListener& hsaAccelerometerDataMesgListener) +{ + std::vector::iterator it = std::find(hsaAccelerometerDataMesgListeners.begin(), hsaAccelerometerDataMesgListeners.end(), &hsaAccelerometerDataMesgListener); + if (hsaAccelerometerDataMesgListeners.end() != it) + hsaAccelerometerDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaGyroscopeDataMesgListener& hsaGyroscopeDataMesgListener) +{ + hsaGyroscopeDataMesgListeners.push_back(&hsaGyroscopeDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaGyroscopeDataMesgListener& hsaGyroscopeDataMesgListener) +{ + std::vector::iterator it = std::find(hsaGyroscopeDataMesgListeners.begin(), hsaGyroscopeDataMesgListeners.end(), &hsaGyroscopeDataMesgListener); + if (hsaGyroscopeDataMesgListeners.end() != it) + hsaGyroscopeDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaStepDataMesgListener& hsaStepDataMesgListener) +{ + hsaStepDataMesgListeners.push_back(&hsaStepDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaStepDataMesgListener& hsaStepDataMesgListener) +{ + std::vector::iterator it = std::find(hsaStepDataMesgListeners.begin(), hsaStepDataMesgListeners.end(), &hsaStepDataMesgListener); + if (hsaStepDataMesgListeners.end() != it) + hsaStepDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaSpo2DataMesgListener& hsaSpo2DataMesgListener) +{ + hsaSpo2DataMesgListeners.push_back(&hsaSpo2DataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaSpo2DataMesgListener& hsaSpo2DataMesgListener) +{ + std::vector::iterator it = std::find(hsaSpo2DataMesgListeners.begin(), hsaSpo2DataMesgListeners.end(), &hsaSpo2DataMesgListener); + if (hsaSpo2DataMesgListeners.end() != it) + hsaSpo2DataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaStressDataMesgListener& hsaStressDataMesgListener) +{ + hsaStressDataMesgListeners.push_back(&hsaStressDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaStressDataMesgListener& hsaStressDataMesgListener) +{ + std::vector::iterator it = std::find(hsaStressDataMesgListeners.begin(), hsaStressDataMesgListeners.end(), &hsaStressDataMesgListener); + if (hsaStressDataMesgListeners.end() != it) + hsaStressDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaRespirationDataMesgListener& hsaRespirationDataMesgListener) +{ + hsaRespirationDataMesgListeners.push_back(&hsaRespirationDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaRespirationDataMesgListener& hsaRespirationDataMesgListener) +{ + std::vector::iterator it = std::find(hsaRespirationDataMesgListeners.begin(), hsaRespirationDataMesgListeners.end(), &hsaRespirationDataMesgListener); + if (hsaRespirationDataMesgListeners.end() != it) + hsaRespirationDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaHeartRateDataMesgListener& hsaHeartRateDataMesgListener) +{ + hsaHeartRateDataMesgListeners.push_back(&hsaHeartRateDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaHeartRateDataMesgListener& hsaHeartRateDataMesgListener) +{ + std::vector::iterator it = std::find(hsaHeartRateDataMesgListeners.begin(), hsaHeartRateDataMesgListeners.end(), &hsaHeartRateDataMesgListener); + if (hsaHeartRateDataMesgListeners.end() != it) + hsaHeartRateDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaConfigurationDataMesgListener& hsaConfigurationDataMesgListener) +{ + hsaConfigurationDataMesgListeners.push_back(&hsaConfigurationDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaConfigurationDataMesgListener& hsaConfigurationDataMesgListener) +{ + std::vector::iterator it = std::find(hsaConfigurationDataMesgListeners.begin(), hsaConfigurationDataMesgListeners.end(), &hsaConfigurationDataMesgListener); + if (hsaConfigurationDataMesgListeners.end() != it) + hsaConfigurationDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HsaWristTemperatureDataMesgListener& hsaWristTemperatureDataMesgListener) +{ + hsaWristTemperatureDataMesgListeners.push_back(&hsaWristTemperatureDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(HsaWristTemperatureDataMesgListener& hsaWristTemperatureDataMesgListener) +{ + std::vector::iterator it = std::find(hsaWristTemperatureDataMesgListeners.begin(), hsaWristTemperatureDataMesgListeners.end(), &hsaWristTemperatureDataMesgListener); + if (hsaWristTemperatureDataMesgListeners.end() != it) + hsaWristTemperatureDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(MemoGlobMesgListener& memoGlobMesgListener) +{ + memoGlobMesgListeners.push_back(&memoGlobMesgListener); +} + +void MesgBroadcaster::RemoveListener(MemoGlobMesgListener& memoGlobMesgListener) +{ + std::vector::iterator it = std::find(memoGlobMesgListeners.begin(), memoGlobMesgListeners.end(), &memoGlobMesgListener); + if (memoGlobMesgListeners.end() != it) + memoGlobMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SleepLevelMesgListener& sleepLevelMesgListener) +{ + sleepLevelMesgListeners.push_back(&sleepLevelMesgListener); +} + +void MesgBroadcaster::RemoveListener(SleepLevelMesgListener& sleepLevelMesgListener) +{ + std::vector::iterator it = std::find(sleepLevelMesgListeners.begin(), sleepLevelMesgListeners.end(), &sleepLevelMesgListener); + if (sleepLevelMesgListeners.end() != it) + sleepLevelMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(AntChannelIdMesgListener& antChannelIdMesgListener) +{ + antChannelIdMesgListeners.push_back(&antChannelIdMesgListener); +} + +void MesgBroadcaster::RemoveListener(AntChannelIdMesgListener& antChannelIdMesgListener) +{ + std::vector::iterator it = std::find(antChannelIdMesgListeners.begin(), antChannelIdMesgListeners.end(), &antChannelIdMesgListener); + if (antChannelIdMesgListeners.end() != it) + antChannelIdMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(AntRxMesgListener& antRxMesgListener) +{ + antRxMesgListeners.push_back(&antRxMesgListener); +} + +void MesgBroadcaster::RemoveListener(AntRxMesgListener& antRxMesgListener) +{ + std::vector::iterator it = std::find(antRxMesgListeners.begin(), antRxMesgListeners.end(), &antRxMesgListener); + if (antRxMesgListeners.end() != it) + antRxMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(AntTxMesgListener& antTxMesgListener) +{ + antTxMesgListeners.push_back(&antTxMesgListener); +} + +void MesgBroadcaster::RemoveListener(AntTxMesgListener& antTxMesgListener) +{ + std::vector::iterator it = std::find(antTxMesgListeners.begin(), antTxMesgListeners.end(), &antTxMesgListener); + if (antTxMesgListeners.end() != it) + antTxMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ExdScreenConfigurationMesgListener& exdScreenConfigurationMesgListener) +{ + exdScreenConfigurationMesgListeners.push_back(&exdScreenConfigurationMesgListener); +} + +void MesgBroadcaster::RemoveListener(ExdScreenConfigurationMesgListener& exdScreenConfigurationMesgListener) +{ + std::vector::iterator it = std::find(exdScreenConfigurationMesgListeners.begin(), exdScreenConfigurationMesgListeners.end(), &exdScreenConfigurationMesgListener); + if (exdScreenConfigurationMesgListeners.end() != it) + exdScreenConfigurationMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ExdDataFieldConfigurationMesgListener& exdDataFieldConfigurationMesgListener) +{ + exdDataFieldConfigurationMesgListeners.push_back(&exdDataFieldConfigurationMesgListener); +} + +void MesgBroadcaster::RemoveListener(ExdDataFieldConfigurationMesgListener& exdDataFieldConfigurationMesgListener) +{ + std::vector::iterator it = std::find(exdDataFieldConfigurationMesgListeners.begin(), exdDataFieldConfigurationMesgListeners.end(), &exdDataFieldConfigurationMesgListener); + if (exdDataFieldConfigurationMesgListeners.end() != it) + exdDataFieldConfigurationMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ExdDataConceptConfigurationMesgListener& exdDataConceptConfigurationMesgListener) +{ + exdDataConceptConfigurationMesgListeners.push_back(&exdDataConceptConfigurationMesgListener); +} + +void MesgBroadcaster::RemoveListener(ExdDataConceptConfigurationMesgListener& exdDataConceptConfigurationMesgListener) +{ + std::vector::iterator it = std::find(exdDataConceptConfigurationMesgListeners.begin(), exdDataConceptConfigurationMesgListeners.end(), &exdDataConceptConfigurationMesgListener); + if (exdDataConceptConfigurationMesgListeners.end() != it) + exdDataConceptConfigurationMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(DiveSummaryMesgListener& diveSummaryMesgListener) +{ + diveSummaryMesgListeners.push_back(&diveSummaryMesgListener); +} + +void MesgBroadcaster::RemoveListener(DiveSummaryMesgListener& diveSummaryMesgListener) +{ + std::vector::iterator it = std::find(diveSummaryMesgListeners.begin(), diveSummaryMesgListeners.end(), &diveSummaryMesgListener); + if (diveSummaryMesgListeners.end() != it) + diveSummaryMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(AadAccelFeaturesMesgListener& aadAccelFeaturesMesgListener) +{ + aadAccelFeaturesMesgListeners.push_back(&aadAccelFeaturesMesgListener); +} + +void MesgBroadcaster::RemoveListener(AadAccelFeaturesMesgListener& aadAccelFeaturesMesgListener) +{ + std::vector::iterator it = std::find(aadAccelFeaturesMesgListeners.begin(), aadAccelFeaturesMesgListeners.end(), &aadAccelFeaturesMesgListener); + if (aadAccelFeaturesMesgListeners.end() != it) + aadAccelFeaturesMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HrvMesgListener& hrvMesgListener) +{ + hrvMesgListeners.push_back(&hrvMesgListener); +} + +void MesgBroadcaster::RemoveListener(HrvMesgListener& hrvMesgListener) +{ + std::vector::iterator it = std::find(hrvMesgListeners.begin(), hrvMesgListeners.end(), &hrvMesgListener); + if (hrvMesgListeners.end() != it) + hrvMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(BeatIntervalsMesgListener& beatIntervalsMesgListener) +{ + beatIntervalsMesgListeners.push_back(&beatIntervalsMesgListener); +} + +void MesgBroadcaster::RemoveListener(BeatIntervalsMesgListener& beatIntervalsMesgListener) +{ + std::vector::iterator it = std::find(beatIntervalsMesgListeners.begin(), beatIntervalsMesgListeners.end(), &beatIntervalsMesgListener); + if (beatIntervalsMesgListeners.end() != it) + beatIntervalsMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HrvStatusSummaryMesgListener& hrvStatusSummaryMesgListener) +{ + hrvStatusSummaryMesgListeners.push_back(&hrvStatusSummaryMesgListener); +} + +void MesgBroadcaster::RemoveListener(HrvStatusSummaryMesgListener& hrvStatusSummaryMesgListener) +{ + std::vector::iterator it = std::find(hrvStatusSummaryMesgListeners.begin(), hrvStatusSummaryMesgListeners.end(), &hrvStatusSummaryMesgListener); + if (hrvStatusSummaryMesgListeners.end() != it) + hrvStatusSummaryMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(HrvValueMesgListener& hrvValueMesgListener) +{ + hrvValueMesgListeners.push_back(&hrvValueMesgListener); +} + +void MesgBroadcaster::RemoveListener(HrvValueMesgListener& hrvValueMesgListener) +{ + std::vector::iterator it = std::find(hrvValueMesgListeners.begin(), hrvValueMesgListeners.end(), &hrvValueMesgListener); + if (hrvValueMesgListeners.end() != it) + hrvValueMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(RawBbiMesgListener& rawBbiMesgListener) +{ + rawBbiMesgListeners.push_back(&rawBbiMesgListener); +} + +void MesgBroadcaster::RemoveListener(RawBbiMesgListener& rawBbiMesgListener) +{ + std::vector::iterator it = std::find(rawBbiMesgListeners.begin(), rawBbiMesgListeners.end(), &rawBbiMesgListener); + if (rawBbiMesgListeners.end() != it) + rawBbiMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(RespirationRateMesgListener& respirationRateMesgListener) +{ + respirationRateMesgListeners.push_back(&respirationRateMesgListener); +} + +void MesgBroadcaster::RemoveListener(RespirationRateMesgListener& respirationRateMesgListener) +{ + std::vector::iterator it = std::find(respirationRateMesgListeners.begin(), respirationRateMesgListeners.end(), &respirationRateMesgListener); + if (respirationRateMesgListeners.end() != it) + respirationRateMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ChronoShotSessionMesgListener& chronoShotSessionMesgListener) +{ + chronoShotSessionMesgListeners.push_back(&chronoShotSessionMesgListener); +} + +void MesgBroadcaster::RemoveListener(ChronoShotSessionMesgListener& chronoShotSessionMesgListener) +{ + std::vector::iterator it = std::find(chronoShotSessionMesgListeners.begin(), chronoShotSessionMesgListeners.end(), &chronoShotSessionMesgListener); + if (chronoShotSessionMesgListeners.end() != it) + chronoShotSessionMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(ChronoShotDataMesgListener& chronoShotDataMesgListener) +{ + chronoShotDataMesgListeners.push_back(&chronoShotDataMesgListener); +} + +void MesgBroadcaster::RemoveListener(ChronoShotDataMesgListener& chronoShotDataMesgListener) +{ + std::vector::iterator it = std::find(chronoShotDataMesgListeners.begin(), chronoShotDataMesgListeners.end(), &chronoShotDataMesgListener); + if (chronoShotDataMesgListeners.end() != it) + chronoShotDataMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TankUpdateMesgListener& tankUpdateMesgListener) +{ + tankUpdateMesgListeners.push_back(&tankUpdateMesgListener); +} + +void MesgBroadcaster::RemoveListener(TankUpdateMesgListener& tankUpdateMesgListener) +{ + std::vector::iterator it = std::find(tankUpdateMesgListeners.begin(), tankUpdateMesgListeners.end(), &tankUpdateMesgListener); + if (tankUpdateMesgListeners.end() != it) + tankUpdateMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(TankSummaryMesgListener& tankSummaryMesgListener) +{ + tankSummaryMesgListeners.push_back(&tankSummaryMesgListener); +} + +void MesgBroadcaster::RemoveListener(TankSummaryMesgListener& tankSummaryMesgListener) +{ + std::vector::iterator it = std::find(tankSummaryMesgListeners.begin(), tankSummaryMesgListeners.end(), &tankSummaryMesgListener); + if (tankSummaryMesgListeners.end() != it) + tankSummaryMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SleepAssessmentMesgListener& sleepAssessmentMesgListener) +{ + sleepAssessmentMesgListeners.push_back(&sleepAssessmentMesgListener); +} + +void MesgBroadcaster::RemoveListener(SleepAssessmentMesgListener& sleepAssessmentMesgListener) +{ + std::vector::iterator it = std::find(sleepAssessmentMesgListeners.begin(), sleepAssessmentMesgListeners.end(), &sleepAssessmentMesgListener); + if (sleepAssessmentMesgListeners.end() != it) + sleepAssessmentMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SleepDisruptionSeverityPeriodMesgListener& sleepDisruptionSeverityPeriodMesgListener) +{ + sleepDisruptionSeverityPeriodMesgListeners.push_back(&sleepDisruptionSeverityPeriodMesgListener); +} + +void MesgBroadcaster::RemoveListener(SleepDisruptionSeverityPeriodMesgListener& sleepDisruptionSeverityPeriodMesgListener) +{ + std::vector::iterator it = std::find(sleepDisruptionSeverityPeriodMesgListeners.begin(), sleepDisruptionSeverityPeriodMesgListeners.end(), &sleepDisruptionSeverityPeriodMesgListener); + if (sleepDisruptionSeverityPeriodMesgListeners.end() != it) + sleepDisruptionSeverityPeriodMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SleepDisruptionOvernightSeverityMesgListener& sleepDisruptionOvernightSeverityMesgListener) +{ + sleepDisruptionOvernightSeverityMesgListeners.push_back(&sleepDisruptionOvernightSeverityMesgListener); +} + +void MesgBroadcaster::RemoveListener(SleepDisruptionOvernightSeverityMesgListener& sleepDisruptionOvernightSeverityMesgListener) +{ + std::vector::iterator it = std::find(sleepDisruptionOvernightSeverityMesgListeners.begin(), sleepDisruptionOvernightSeverityMesgListeners.end(), &sleepDisruptionOvernightSeverityMesgListener); + if (sleepDisruptionOvernightSeverityMesgListeners.end() != it) + sleepDisruptionOvernightSeverityMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(SkinTempOvernightMesgListener& skinTempOvernightMesgListener) +{ + skinTempOvernightMesgListeners.push_back(&skinTempOvernightMesgListener); +} + +void MesgBroadcaster::RemoveListener(SkinTempOvernightMesgListener& skinTempOvernightMesgListener) +{ + std::vector::iterator it = std::find(skinTempOvernightMesgListeners.begin(), skinTempOvernightMesgListeners.end(), &skinTempOvernightMesgListener); + if (skinTempOvernightMesgListeners.end() != it) + skinTempOvernightMesgListeners.erase(it); +} + + +void MesgBroadcaster::AddListener(PadMesgListener& padMesgListener) +{ + padMesgListeners.push_back(&padMesgListener); +} + +void MesgBroadcaster::RemoveListener(PadMesgListener& padMesgListener) +{ + std::vector::iterator it = std::find(padMesgListeners.begin(), padMesgListeners.end(), &padMesgListener); + if (padMesgListeners.end() != it) + padMesgListeners.erase(it); +} + + + +void MesgBroadcaster::OnMesg(Mesg& mesg) +{ + for (int i=0; i < (int)mesgListeners.size(); i++) + mesgListeners[i]->OnMesg(mesg); + + switch (mesg.GetNum()) + { + case FIT_MESG_NUM_FILE_ID: + { + FileIdMesg fileIdMesg(mesg); + for (int i=0; i < (int)fileIdMesgListeners.size(); i++) + fileIdMesgListeners[i]->OnMesg(fileIdMesg); + break; + } + case FIT_MESG_NUM_FILE_CREATOR: + { + FileCreatorMesg fileCreatorMesg(mesg); + for (int i=0; i < (int)fileCreatorMesgListeners.size(); i++) + fileCreatorMesgListeners[i]->OnMesg(fileCreatorMesg); + break; + } + case FIT_MESG_NUM_TIMESTAMP_CORRELATION: + { + TimestampCorrelationMesg timestampCorrelationMesg(mesg); + for (int i=0; i < (int)timestampCorrelationMesgListeners.size(); i++) + timestampCorrelationMesgListeners[i]->OnMesg(timestampCorrelationMesg); + break; + } + case FIT_MESG_NUM_SOFTWARE: + { + SoftwareMesg softwareMesg(mesg); + for (int i=0; i < (int)softwareMesgListeners.size(); i++) + softwareMesgListeners[i]->OnMesg(softwareMesg); + break; + } + case FIT_MESG_NUM_SLAVE_DEVICE: + { + SlaveDeviceMesg slaveDeviceMesg(mesg); + for (int i=0; i < (int)slaveDeviceMesgListeners.size(); i++) + slaveDeviceMesgListeners[i]->OnMesg(slaveDeviceMesg); + break; + } + case FIT_MESG_NUM_CAPABILITIES: + { + CapabilitiesMesg capabilitiesMesg(mesg); + for (int i=0; i < (int)capabilitiesMesgListeners.size(); i++) + capabilitiesMesgListeners[i]->OnMesg(capabilitiesMesg); + break; + } + case FIT_MESG_NUM_FILE_CAPABILITIES: + { + FileCapabilitiesMesg fileCapabilitiesMesg(mesg); + for (int i=0; i < (int)fileCapabilitiesMesgListeners.size(); i++) + fileCapabilitiesMesgListeners[i]->OnMesg(fileCapabilitiesMesg); + break; + } + case FIT_MESG_NUM_MESG_CAPABILITIES: + { + MesgCapabilitiesMesg mesgCapabilitiesMesg(mesg); + for (int i=0; i < (int)mesgCapabilitiesMesgListeners.size(); i++) + mesgCapabilitiesMesgListeners[i]->OnMesg(mesgCapabilitiesMesg); + break; + } + case FIT_MESG_NUM_FIELD_CAPABILITIES: + { + FieldCapabilitiesMesg fieldCapabilitiesMesg(mesg); + for (int i=0; i < (int)fieldCapabilitiesMesgListeners.size(); i++) + fieldCapabilitiesMesgListeners[i]->OnMesg(fieldCapabilitiesMesg); + break; + } + case FIT_MESG_NUM_DEVICE_SETTINGS: + { + DeviceSettingsMesg deviceSettingsMesg(mesg); + for (int i=0; i < (int)deviceSettingsMesgListeners.size(); i++) + deviceSettingsMesgListeners[i]->OnMesg(deviceSettingsMesg); + break; + } + case FIT_MESG_NUM_USER_PROFILE: + { + UserProfileMesg userProfileMesg(mesg); + for (int i=0; i < (int)userProfileMesgListeners.size(); i++) + userProfileMesgListeners[i]->OnMesg(userProfileMesg); + break; + } + case FIT_MESG_NUM_HRM_PROFILE: + { + HrmProfileMesg hrmProfileMesg(mesg); + for (int i=0; i < (int)hrmProfileMesgListeners.size(); i++) + hrmProfileMesgListeners[i]->OnMesg(hrmProfileMesg); + break; + } + case FIT_MESG_NUM_SDM_PROFILE: + { + SdmProfileMesg sdmProfileMesg(mesg); + for (int i=0; i < (int)sdmProfileMesgListeners.size(); i++) + sdmProfileMesgListeners[i]->OnMesg(sdmProfileMesg); + break; + } + case FIT_MESG_NUM_BIKE_PROFILE: + { + BikeProfileMesg bikeProfileMesg(mesg); + for (int i=0; i < (int)bikeProfileMesgListeners.size(); i++) + bikeProfileMesgListeners[i]->OnMesg(bikeProfileMesg); + break; + } + case FIT_MESG_NUM_CONNECTIVITY: + { + ConnectivityMesg connectivityMesg(mesg); + for (int i=0; i < (int)connectivityMesgListeners.size(); i++) + connectivityMesgListeners[i]->OnMesg(connectivityMesg); + break; + } + case FIT_MESG_NUM_WATCHFACE_SETTINGS: + { + WatchfaceSettingsMesg watchfaceSettingsMesg(mesg); + for (int i=0; i < (int)watchfaceSettingsMesgListeners.size(); i++) + watchfaceSettingsMesgListeners[i]->OnMesg(watchfaceSettingsMesg); + break; + } + case FIT_MESG_NUM_OHR_SETTINGS: + { + OhrSettingsMesg ohrSettingsMesg(mesg); + for (int i=0; i < (int)ohrSettingsMesgListeners.size(); i++) + ohrSettingsMesgListeners[i]->OnMesg(ohrSettingsMesg); + break; + } + case FIT_MESG_NUM_TIME_IN_ZONE: + { + TimeInZoneMesg timeInZoneMesg(mesg); + for (int i=0; i < (int)timeInZoneMesgListeners.size(); i++) + timeInZoneMesgListeners[i]->OnMesg(timeInZoneMesg); + break; + } + case FIT_MESG_NUM_ZONES_TARGET: + { + ZonesTargetMesg zonesTargetMesg(mesg); + for (int i=0; i < (int)zonesTargetMesgListeners.size(); i++) + zonesTargetMesgListeners[i]->OnMesg(zonesTargetMesg); + break; + } + case FIT_MESG_NUM_SPORT: + { + SportMesg sportMesg(mesg); + for (int i=0; i < (int)sportMesgListeners.size(); i++) + sportMesgListeners[i]->OnMesg(sportMesg); + break; + } + case FIT_MESG_NUM_HR_ZONE: + { + HrZoneMesg hrZoneMesg(mesg); + for (int i=0; i < (int)hrZoneMesgListeners.size(); i++) + hrZoneMesgListeners[i]->OnMesg(hrZoneMesg); + break; + } + case FIT_MESG_NUM_SPEED_ZONE: + { + SpeedZoneMesg speedZoneMesg(mesg); + for (int i=0; i < (int)speedZoneMesgListeners.size(); i++) + speedZoneMesgListeners[i]->OnMesg(speedZoneMesg); + break; + } + case FIT_MESG_NUM_CADENCE_ZONE: + { + CadenceZoneMesg cadenceZoneMesg(mesg); + for (int i=0; i < (int)cadenceZoneMesgListeners.size(); i++) + cadenceZoneMesgListeners[i]->OnMesg(cadenceZoneMesg); + break; + } + case FIT_MESG_NUM_POWER_ZONE: + { + PowerZoneMesg powerZoneMesg(mesg); + for (int i=0; i < (int)powerZoneMesgListeners.size(); i++) + powerZoneMesgListeners[i]->OnMesg(powerZoneMesg); + break; + } + case FIT_MESG_NUM_MET_ZONE: + { + MetZoneMesg metZoneMesg(mesg); + for (int i=0; i < (int)metZoneMesgListeners.size(); i++) + metZoneMesgListeners[i]->OnMesg(metZoneMesg); + break; + } + case FIT_MESG_NUM_TRAINING_SETTINGS: + { + TrainingSettingsMesg trainingSettingsMesg(mesg); + for (int i=0; i < (int)trainingSettingsMesgListeners.size(); i++) + trainingSettingsMesgListeners[i]->OnMesg(trainingSettingsMesg); + break; + } + case FIT_MESG_NUM_DIVE_SETTINGS: + { + DiveSettingsMesg diveSettingsMesg(mesg); + for (int i=0; i < (int)diveSettingsMesgListeners.size(); i++) + diveSettingsMesgListeners[i]->OnMesg(diveSettingsMesg); + break; + } + case FIT_MESG_NUM_DIVE_ALARM: + { + DiveAlarmMesg diveAlarmMesg(mesg); + for (int i=0; i < (int)diveAlarmMesgListeners.size(); i++) + diveAlarmMesgListeners[i]->OnMesg(diveAlarmMesg); + break; + } + case FIT_MESG_NUM_DIVE_APNEA_ALARM: + { + DiveApneaAlarmMesg diveApneaAlarmMesg(mesg); + for (int i=0; i < (int)diveApneaAlarmMesgListeners.size(); i++) + diveApneaAlarmMesgListeners[i]->OnMesg(diveApneaAlarmMesg); + break; + } + case FIT_MESG_NUM_DIVE_GAS: + { + DiveGasMesg diveGasMesg(mesg); + for (int i=0; i < (int)diveGasMesgListeners.size(); i++) + diveGasMesgListeners[i]->OnMesg(diveGasMesg); + break; + } + case FIT_MESG_NUM_GOAL: + { + GoalMesg goalMesg(mesg); + for (int i=0; i < (int)goalMesgListeners.size(); i++) + goalMesgListeners[i]->OnMesg(goalMesg); + break; + } + case FIT_MESG_NUM_ACTIVITY: + { + ActivityMesg activityMesg(mesg); + for (int i=0; i < (int)activityMesgListeners.size(); i++) + activityMesgListeners[i]->OnMesg(activityMesg); + mesgWithEventBroadcaster.OnMesg(activityMesg); + break; + } + case FIT_MESG_NUM_SESSION: + { + SessionMesg sessionMesg(mesg); + for (int i=0; i < (int)sessionMesgListeners.size(); i++) + sessionMesgListeners[i]->OnMesg(sessionMesg); + mesgWithEventBroadcaster.OnMesg(sessionMesg); + break; + } + case FIT_MESG_NUM_LAP: + { + LapMesg lapMesg(mesg); + for (int i=0; i < (int)lapMesgListeners.size(); i++) + lapMesgListeners[i]->OnMesg(lapMesg); + mesgWithEventBroadcaster.OnMesg(lapMesg); + break; + } + case FIT_MESG_NUM_LENGTH: + { + LengthMesg lengthMesg(mesg); + for (int i=0; i < (int)lengthMesgListeners.size(); i++) + lengthMesgListeners[i]->OnMesg(lengthMesg); + mesgWithEventBroadcaster.OnMesg(lengthMesg); + break; + } + case FIT_MESG_NUM_RECORD: + { + RecordMesg recordMesg(mesg); + for (int i=0; i < (int)recordMesgListeners.size(); i++) + recordMesgListeners[i]->OnMesg(recordMesg); + bufferedRecordMesgBroadcaster.OnMesg(recordMesg); + break; + } + case FIT_MESG_NUM_EVENT: + { + EventMesg eventMesg(mesg); + for (int i=0; i < (int)eventMesgListeners.size(); i++) + eventMesgListeners[i]->OnMesg(eventMesg); + mesgWithEventBroadcaster.OnMesg(eventMesg); + break; + } + case FIT_MESG_NUM_DEVICE_INFO: + { + DeviceInfoMesg deviceInfoMesg(mesg); + for (int i=0; i < (int)deviceInfoMesgListeners.size(); i++) + deviceInfoMesgListeners[i]->OnMesg(deviceInfoMesg); + break; + } + case FIT_MESG_NUM_DEVICE_AUX_BATTERY_INFO: + { + DeviceAuxBatteryInfoMesg deviceAuxBatteryInfoMesg(mesg); + for (int i=0; i < (int)deviceAuxBatteryInfoMesgListeners.size(); i++) + deviceAuxBatteryInfoMesgListeners[i]->OnMesg(deviceAuxBatteryInfoMesg); + break; + } + case FIT_MESG_NUM_TRAINING_FILE: + { + TrainingFileMesg trainingFileMesg(mesg); + for (int i=0; i < (int)trainingFileMesgListeners.size(); i++) + trainingFileMesgListeners[i]->OnMesg(trainingFileMesg); + break; + } + case FIT_MESG_NUM_WEATHER_CONDITIONS: + { + WeatherConditionsMesg weatherConditionsMesg(mesg); + for (int i=0; i < (int)weatherConditionsMesgListeners.size(); i++) + weatherConditionsMesgListeners[i]->OnMesg(weatherConditionsMesg); + break; + } + case FIT_MESG_NUM_WEATHER_ALERT: + { + WeatherAlertMesg weatherAlertMesg(mesg); + for (int i=0; i < (int)weatherAlertMesgListeners.size(); i++) + weatherAlertMesgListeners[i]->OnMesg(weatherAlertMesg); + break; + } + case FIT_MESG_NUM_GPS_METADATA: + { + GpsMetadataMesg gpsMetadataMesg(mesg); + for (int i=0; i < (int)gpsMetadataMesgListeners.size(); i++) + gpsMetadataMesgListeners[i]->OnMesg(gpsMetadataMesg); + break; + } + case FIT_MESG_NUM_CAMERA_EVENT: + { + CameraEventMesg cameraEventMesg(mesg); + for (int i=0; i < (int)cameraEventMesgListeners.size(); i++) + cameraEventMesgListeners[i]->OnMesg(cameraEventMesg); + break; + } + case FIT_MESG_NUM_GYROSCOPE_DATA: + { + GyroscopeDataMesg gyroscopeDataMesg(mesg); + for (int i=0; i < (int)gyroscopeDataMesgListeners.size(); i++) + gyroscopeDataMesgListeners[i]->OnMesg(gyroscopeDataMesg); + break; + } + case FIT_MESG_NUM_ACCELEROMETER_DATA: + { + AccelerometerDataMesg accelerometerDataMesg(mesg); + for (int i=0; i < (int)accelerometerDataMesgListeners.size(); i++) + accelerometerDataMesgListeners[i]->OnMesg(accelerometerDataMesg); + break; + } + case FIT_MESG_NUM_MAGNETOMETER_DATA: + { + MagnetometerDataMesg magnetometerDataMesg(mesg); + for (int i=0; i < (int)magnetometerDataMesgListeners.size(); i++) + magnetometerDataMesgListeners[i]->OnMesg(magnetometerDataMesg); + break; + } + case FIT_MESG_NUM_BAROMETER_DATA: + { + BarometerDataMesg barometerDataMesg(mesg); + for (int i=0; i < (int)barometerDataMesgListeners.size(); i++) + barometerDataMesgListeners[i]->OnMesg(barometerDataMesg); + break; + } + case FIT_MESG_NUM_THREE_D_SENSOR_CALIBRATION: + { + ThreeDSensorCalibrationMesg threeDSensorCalibrationMesg(mesg); + for (int i=0; i < (int)threeDSensorCalibrationMesgListeners.size(); i++) + threeDSensorCalibrationMesgListeners[i]->OnMesg(threeDSensorCalibrationMesg); + break; + } + case FIT_MESG_NUM_ONE_D_SENSOR_CALIBRATION: + { + OneDSensorCalibrationMesg oneDSensorCalibrationMesg(mesg); + for (int i=0; i < (int)oneDSensorCalibrationMesgListeners.size(); i++) + oneDSensorCalibrationMesgListeners[i]->OnMesg(oneDSensorCalibrationMesg); + break; + } + case FIT_MESG_NUM_VIDEO_FRAME: + { + VideoFrameMesg videoFrameMesg(mesg); + for (int i=0; i < (int)videoFrameMesgListeners.size(); i++) + videoFrameMesgListeners[i]->OnMesg(videoFrameMesg); + break; + } + case FIT_MESG_NUM_OBDII_DATA: + { + ObdiiDataMesg obdiiDataMesg(mesg); + for (int i=0; i < (int)obdiiDataMesgListeners.size(); i++) + obdiiDataMesgListeners[i]->OnMesg(obdiiDataMesg); + break; + } + case FIT_MESG_NUM_NMEA_SENTENCE: + { + NmeaSentenceMesg nmeaSentenceMesg(mesg); + for (int i=0; i < (int)nmeaSentenceMesgListeners.size(); i++) + nmeaSentenceMesgListeners[i]->OnMesg(nmeaSentenceMesg); + break; + } + case FIT_MESG_NUM_AVIATION_ATTITUDE: + { + AviationAttitudeMesg aviationAttitudeMesg(mesg); + for (int i=0; i < (int)aviationAttitudeMesgListeners.size(); i++) + aviationAttitudeMesgListeners[i]->OnMesg(aviationAttitudeMesg); + break; + } + case FIT_MESG_NUM_VIDEO: + { + VideoMesg videoMesg(mesg); + for (int i=0; i < (int)videoMesgListeners.size(); i++) + videoMesgListeners[i]->OnMesg(videoMesg); + break; + } + case FIT_MESG_NUM_VIDEO_TITLE: + { + VideoTitleMesg videoTitleMesg(mesg); + for (int i=0; i < (int)videoTitleMesgListeners.size(); i++) + videoTitleMesgListeners[i]->OnMesg(videoTitleMesg); + break; + } + case FIT_MESG_NUM_VIDEO_DESCRIPTION: + { + VideoDescriptionMesg videoDescriptionMesg(mesg); + for (int i=0; i < (int)videoDescriptionMesgListeners.size(); i++) + videoDescriptionMesgListeners[i]->OnMesg(videoDescriptionMesg); + break; + } + case FIT_MESG_NUM_VIDEO_CLIP: + { + VideoClipMesg videoClipMesg(mesg); + for (int i=0; i < (int)videoClipMesgListeners.size(); i++) + videoClipMesgListeners[i]->OnMesg(videoClipMesg); + break; + } + case FIT_MESG_NUM_SET: + { + SetMesg setMesg(mesg); + for (int i=0; i < (int)setMesgListeners.size(); i++) + setMesgListeners[i]->OnMesg(setMesg); + break; + } + case FIT_MESG_NUM_JUMP: + { + JumpMesg jumpMesg(mesg); + for (int i=0; i < (int)jumpMesgListeners.size(); i++) + jumpMesgListeners[i]->OnMesg(jumpMesg); + break; + } + case FIT_MESG_NUM_SPLIT: + { + SplitMesg splitMesg(mesg); + for (int i=0; i < (int)splitMesgListeners.size(); i++) + splitMesgListeners[i]->OnMesg(splitMesg); + break; + } + case FIT_MESG_NUM_SPLIT_SUMMARY: + { + SplitSummaryMesg splitSummaryMesg(mesg); + for (int i=0; i < (int)splitSummaryMesgListeners.size(); i++) + splitSummaryMesgListeners[i]->OnMesg(splitSummaryMesg); + break; + } + case FIT_MESG_NUM_CLIMB_PRO: + { + ClimbProMesg climbProMesg(mesg); + for (int i=0; i < (int)climbProMesgListeners.size(); i++) + climbProMesgListeners[i]->OnMesg(climbProMesg); + break; + } + case FIT_MESG_NUM_FIELD_DESCRIPTION: + { + FieldDescriptionMesg fieldDescriptionMesg(mesg); + for (int i=0; i < (int)fieldDescriptionMesgListeners.size(); i++) + fieldDescriptionMesgListeners[i]->OnMesg(fieldDescriptionMesg); + break; + } + case FIT_MESG_NUM_DEVELOPER_DATA_ID: + { + DeveloperDataIdMesg developerDataIdMesg(mesg); + for (int i=0; i < (int)developerDataIdMesgListeners.size(); i++) + developerDataIdMesgListeners[i]->OnMesg(developerDataIdMesg); + break; + } + case FIT_MESG_NUM_COURSE: + { + CourseMesg courseMesg(mesg); + for (int i=0; i < (int)courseMesgListeners.size(); i++) + courseMesgListeners[i]->OnMesg(courseMesg); + break; + } + case FIT_MESG_NUM_COURSE_POINT: + { + CoursePointMesg coursePointMesg(mesg); + for (int i=0; i < (int)coursePointMesgListeners.size(); i++) + coursePointMesgListeners[i]->OnMesg(coursePointMesg); + break; + } + case FIT_MESG_NUM_SEGMENT_ID: + { + SegmentIdMesg segmentIdMesg(mesg); + for (int i=0; i < (int)segmentIdMesgListeners.size(); i++) + segmentIdMesgListeners[i]->OnMesg(segmentIdMesg); + break; + } + case FIT_MESG_NUM_SEGMENT_LEADERBOARD_ENTRY: + { + SegmentLeaderboardEntryMesg segmentLeaderboardEntryMesg(mesg); + for (int i=0; i < (int)segmentLeaderboardEntryMesgListeners.size(); i++) + segmentLeaderboardEntryMesgListeners[i]->OnMesg(segmentLeaderboardEntryMesg); + break; + } + case FIT_MESG_NUM_SEGMENT_POINT: + { + SegmentPointMesg segmentPointMesg(mesg); + for (int i=0; i < (int)segmentPointMesgListeners.size(); i++) + segmentPointMesgListeners[i]->OnMesg(segmentPointMesg); + break; + } + case FIT_MESG_NUM_SEGMENT_LAP: + { + SegmentLapMesg segmentLapMesg(mesg); + for (int i=0; i < (int)segmentLapMesgListeners.size(); i++) + segmentLapMesgListeners[i]->OnMesg(segmentLapMesg); + mesgWithEventBroadcaster.OnMesg(segmentLapMesg); + break; + } + case FIT_MESG_NUM_SEGMENT_FILE: + { + SegmentFileMesg segmentFileMesg(mesg); + for (int i=0; i < (int)segmentFileMesgListeners.size(); i++) + segmentFileMesgListeners[i]->OnMesg(segmentFileMesg); + break; + } + case FIT_MESG_NUM_WORKOUT: + { + WorkoutMesg workoutMesg(mesg); + for (int i=0; i < (int)workoutMesgListeners.size(); i++) + workoutMesgListeners[i]->OnMesg(workoutMesg); + break; + } + case FIT_MESG_NUM_WORKOUT_SESSION: + { + WorkoutSessionMesg workoutSessionMesg(mesg); + for (int i=0; i < (int)workoutSessionMesgListeners.size(); i++) + workoutSessionMesgListeners[i]->OnMesg(workoutSessionMesg); + break; + } + case FIT_MESG_NUM_WORKOUT_STEP: + { + WorkoutStepMesg workoutStepMesg(mesg); + for (int i=0; i < (int)workoutStepMesgListeners.size(); i++) + workoutStepMesgListeners[i]->OnMesg(workoutStepMesg); + break; + } + case FIT_MESG_NUM_EXERCISE_TITLE: + { + ExerciseTitleMesg exerciseTitleMesg(mesg); + for (int i=0; i < (int)exerciseTitleMesgListeners.size(); i++) + exerciseTitleMesgListeners[i]->OnMesg(exerciseTitleMesg); + break; + } + case FIT_MESG_NUM_SCHEDULE: + { + ScheduleMesg scheduleMesg(mesg); + for (int i=0; i < (int)scheduleMesgListeners.size(); i++) + scheduleMesgListeners[i]->OnMesg(scheduleMesg); + break; + } + case FIT_MESG_NUM_TOTALS: + { + TotalsMesg totalsMesg(mesg); + for (int i=0; i < (int)totalsMesgListeners.size(); i++) + totalsMesgListeners[i]->OnMesg(totalsMesg); + break; + } + case FIT_MESG_NUM_WEIGHT_SCALE: + { + WeightScaleMesg weightScaleMesg(mesg); + for (int i=0; i < (int)weightScaleMesgListeners.size(); i++) + weightScaleMesgListeners[i]->OnMesg(weightScaleMesg); + break; + } + case FIT_MESG_NUM_BLOOD_PRESSURE: + { + BloodPressureMesg bloodPressureMesg(mesg); + for (int i=0; i < (int)bloodPressureMesgListeners.size(); i++) + bloodPressureMesgListeners[i]->OnMesg(bloodPressureMesg); + break; + } + case FIT_MESG_NUM_MONITORING_INFO: + { + MonitoringInfoMesg monitoringInfoMesg(mesg); + for (int i=0; i < (int)monitoringInfoMesgListeners.size(); i++) + monitoringInfoMesgListeners[i]->OnMesg(monitoringInfoMesg); + break; + } + case FIT_MESG_NUM_MONITORING: + { + MonitoringMesg monitoringMesg(mesg); + for (int i=0; i < (int)monitoringMesgListeners.size(); i++) + monitoringMesgListeners[i]->OnMesg(monitoringMesg); + break; + } + case FIT_MESG_NUM_MONITORING_HR_DATA: + { + MonitoringHrDataMesg monitoringHrDataMesg(mesg); + for (int i=0; i < (int)monitoringHrDataMesgListeners.size(); i++) + monitoringHrDataMesgListeners[i]->OnMesg(monitoringHrDataMesg); + break; + } + case FIT_MESG_NUM_SPO2_DATA: + { + Spo2DataMesg spo2DataMesg(mesg); + for (int i=0; i < (int)spo2DataMesgListeners.size(); i++) + spo2DataMesgListeners[i]->OnMesg(spo2DataMesg); + break; + } + case FIT_MESG_NUM_HR: + { + HrMesg hrMesg(mesg); + for (int i=0; i < (int)hrMesgListeners.size(); i++) + hrMesgListeners[i]->OnMesg(hrMesg); + break; + } + case FIT_MESG_NUM_STRESS_LEVEL: + { + StressLevelMesg stressLevelMesg(mesg); + for (int i=0; i < (int)stressLevelMesgListeners.size(); i++) + stressLevelMesgListeners[i]->OnMesg(stressLevelMesg); + break; + } + case FIT_MESG_NUM_MAX_MET_DATA: + { + MaxMetDataMesg maxMetDataMesg(mesg); + for (int i=0; i < (int)maxMetDataMesgListeners.size(); i++) + maxMetDataMesgListeners[i]->OnMesg(maxMetDataMesg); + break; + } + case FIT_MESG_NUM_HSA_BODY_BATTERY_DATA: + { + HsaBodyBatteryDataMesg hsaBodyBatteryDataMesg(mesg); + for (int i=0; i < (int)hsaBodyBatteryDataMesgListeners.size(); i++) + hsaBodyBatteryDataMesgListeners[i]->OnMesg(hsaBodyBatteryDataMesg); + break; + } + case FIT_MESG_NUM_HSA_EVENT: + { + HsaEventMesg hsaEventMesg(mesg); + for (int i=0; i < (int)hsaEventMesgListeners.size(); i++) + hsaEventMesgListeners[i]->OnMesg(hsaEventMesg); + break; + } + case FIT_MESG_NUM_HSA_ACCELEROMETER_DATA: + { + HsaAccelerometerDataMesg hsaAccelerometerDataMesg(mesg); + for (int i=0; i < (int)hsaAccelerometerDataMesgListeners.size(); i++) + hsaAccelerometerDataMesgListeners[i]->OnMesg(hsaAccelerometerDataMesg); + break; + } + case FIT_MESG_NUM_HSA_GYROSCOPE_DATA: + { + HsaGyroscopeDataMesg hsaGyroscopeDataMesg(mesg); + for (int i=0; i < (int)hsaGyroscopeDataMesgListeners.size(); i++) + hsaGyroscopeDataMesgListeners[i]->OnMesg(hsaGyroscopeDataMesg); + break; + } + case FIT_MESG_NUM_HSA_STEP_DATA: + { + HsaStepDataMesg hsaStepDataMesg(mesg); + for (int i=0; i < (int)hsaStepDataMesgListeners.size(); i++) + hsaStepDataMesgListeners[i]->OnMesg(hsaStepDataMesg); + break; + } + case FIT_MESG_NUM_HSA_SPO2_DATA: + { + HsaSpo2DataMesg hsaSpo2DataMesg(mesg); + for (int i=0; i < (int)hsaSpo2DataMesgListeners.size(); i++) + hsaSpo2DataMesgListeners[i]->OnMesg(hsaSpo2DataMesg); + break; + } + case FIT_MESG_NUM_HSA_STRESS_DATA: + { + HsaStressDataMesg hsaStressDataMesg(mesg); + for (int i=0; i < (int)hsaStressDataMesgListeners.size(); i++) + hsaStressDataMesgListeners[i]->OnMesg(hsaStressDataMesg); + break; + } + case FIT_MESG_NUM_HSA_RESPIRATION_DATA: + { + HsaRespirationDataMesg hsaRespirationDataMesg(mesg); + for (int i=0; i < (int)hsaRespirationDataMesgListeners.size(); i++) + hsaRespirationDataMesgListeners[i]->OnMesg(hsaRespirationDataMesg); + break; + } + case FIT_MESG_NUM_HSA_HEART_RATE_DATA: + { + HsaHeartRateDataMesg hsaHeartRateDataMesg(mesg); + for (int i=0; i < (int)hsaHeartRateDataMesgListeners.size(); i++) + hsaHeartRateDataMesgListeners[i]->OnMesg(hsaHeartRateDataMesg); + break; + } + case FIT_MESG_NUM_HSA_CONFIGURATION_DATA: + { + HsaConfigurationDataMesg hsaConfigurationDataMesg(mesg); + for (int i=0; i < (int)hsaConfigurationDataMesgListeners.size(); i++) + hsaConfigurationDataMesgListeners[i]->OnMesg(hsaConfigurationDataMesg); + break; + } + case FIT_MESG_NUM_HSA_WRIST_TEMPERATURE_DATA: + { + HsaWristTemperatureDataMesg hsaWristTemperatureDataMesg(mesg); + for (int i=0; i < (int)hsaWristTemperatureDataMesgListeners.size(); i++) + hsaWristTemperatureDataMesgListeners[i]->OnMesg(hsaWristTemperatureDataMesg); + break; + } + case FIT_MESG_NUM_MEMO_GLOB: + { + MemoGlobMesg memoGlobMesg(mesg); + for (int i=0; i < (int)memoGlobMesgListeners.size(); i++) + memoGlobMesgListeners[i]->OnMesg(memoGlobMesg); + break; + } + case FIT_MESG_NUM_SLEEP_LEVEL: + { + SleepLevelMesg sleepLevelMesg(mesg); + for (int i=0; i < (int)sleepLevelMesgListeners.size(); i++) + sleepLevelMesgListeners[i]->OnMesg(sleepLevelMesg); + break; + } + case FIT_MESG_NUM_ANT_CHANNEL_ID: + { + AntChannelIdMesg antChannelIdMesg(mesg); + for (int i=0; i < (int)antChannelIdMesgListeners.size(); i++) + antChannelIdMesgListeners[i]->OnMesg(antChannelIdMesg); + break; + } + case FIT_MESG_NUM_ANT_RX: + { + AntRxMesg antRxMesg(mesg); + for (int i=0; i < (int)antRxMesgListeners.size(); i++) + antRxMesgListeners[i]->OnMesg(antRxMesg); + break; + } + case FIT_MESG_NUM_ANT_TX: + { + AntTxMesg antTxMesg(mesg); + for (int i=0; i < (int)antTxMesgListeners.size(); i++) + antTxMesgListeners[i]->OnMesg(antTxMesg); + break; + } + case FIT_MESG_NUM_EXD_SCREEN_CONFIGURATION: + { + ExdScreenConfigurationMesg exdScreenConfigurationMesg(mesg); + for (int i=0; i < (int)exdScreenConfigurationMesgListeners.size(); i++) + exdScreenConfigurationMesgListeners[i]->OnMesg(exdScreenConfigurationMesg); + break; + } + case FIT_MESG_NUM_EXD_DATA_FIELD_CONFIGURATION: + { + ExdDataFieldConfigurationMesg exdDataFieldConfigurationMesg(mesg); + for (int i=0; i < (int)exdDataFieldConfigurationMesgListeners.size(); i++) + exdDataFieldConfigurationMesgListeners[i]->OnMesg(exdDataFieldConfigurationMesg); + break; + } + case FIT_MESG_NUM_EXD_DATA_CONCEPT_CONFIGURATION: + { + ExdDataConceptConfigurationMesg exdDataConceptConfigurationMesg(mesg); + for (int i=0; i < (int)exdDataConceptConfigurationMesgListeners.size(); i++) + exdDataConceptConfigurationMesgListeners[i]->OnMesg(exdDataConceptConfigurationMesg); + break; + } + case FIT_MESG_NUM_DIVE_SUMMARY: + { + DiveSummaryMesg diveSummaryMesg(mesg); + for (int i=0; i < (int)diveSummaryMesgListeners.size(); i++) + diveSummaryMesgListeners[i]->OnMesg(diveSummaryMesg); + break; + } + case FIT_MESG_NUM_AAD_ACCEL_FEATURES: + { + AadAccelFeaturesMesg aadAccelFeaturesMesg(mesg); + for (int i=0; i < (int)aadAccelFeaturesMesgListeners.size(); i++) + aadAccelFeaturesMesgListeners[i]->OnMesg(aadAccelFeaturesMesg); + break; + } + case FIT_MESG_NUM_HRV: + { + HrvMesg hrvMesg(mesg); + for (int i=0; i < (int)hrvMesgListeners.size(); i++) + hrvMesgListeners[i]->OnMesg(hrvMesg); + break; + } + case FIT_MESG_NUM_BEAT_INTERVALS: + { + BeatIntervalsMesg beatIntervalsMesg(mesg); + for (int i=0; i < (int)beatIntervalsMesgListeners.size(); i++) + beatIntervalsMesgListeners[i]->OnMesg(beatIntervalsMesg); + break; + } + case FIT_MESG_NUM_HRV_STATUS_SUMMARY: + { + HrvStatusSummaryMesg hrvStatusSummaryMesg(mesg); + for (int i=0; i < (int)hrvStatusSummaryMesgListeners.size(); i++) + hrvStatusSummaryMesgListeners[i]->OnMesg(hrvStatusSummaryMesg); + break; + } + case FIT_MESG_NUM_HRV_VALUE: + { + HrvValueMesg hrvValueMesg(mesg); + for (int i=0; i < (int)hrvValueMesgListeners.size(); i++) + hrvValueMesgListeners[i]->OnMesg(hrvValueMesg); + break; + } + case FIT_MESG_NUM_RAW_BBI: + { + RawBbiMesg rawBbiMesg(mesg); + for (int i=0; i < (int)rawBbiMesgListeners.size(); i++) + rawBbiMesgListeners[i]->OnMesg(rawBbiMesg); + break; + } + case FIT_MESG_NUM_RESPIRATION_RATE: + { + RespirationRateMesg respirationRateMesg(mesg); + for (int i=0; i < (int)respirationRateMesgListeners.size(); i++) + respirationRateMesgListeners[i]->OnMesg(respirationRateMesg); + break; + } + case FIT_MESG_NUM_CHRONO_SHOT_SESSION: + { + ChronoShotSessionMesg chronoShotSessionMesg(mesg); + for (int i=0; i < (int)chronoShotSessionMesgListeners.size(); i++) + chronoShotSessionMesgListeners[i]->OnMesg(chronoShotSessionMesg); + break; + } + case FIT_MESG_NUM_CHRONO_SHOT_DATA: + { + ChronoShotDataMesg chronoShotDataMesg(mesg); + for (int i=0; i < (int)chronoShotDataMesgListeners.size(); i++) + chronoShotDataMesgListeners[i]->OnMesg(chronoShotDataMesg); + break; + } + case FIT_MESG_NUM_TANK_UPDATE: + { + TankUpdateMesg tankUpdateMesg(mesg); + for (int i=0; i < (int)tankUpdateMesgListeners.size(); i++) + tankUpdateMesgListeners[i]->OnMesg(tankUpdateMesg); + break; + } + case FIT_MESG_NUM_TANK_SUMMARY: + { + TankSummaryMesg tankSummaryMesg(mesg); + for (int i=0; i < (int)tankSummaryMesgListeners.size(); i++) + tankSummaryMesgListeners[i]->OnMesg(tankSummaryMesg); + break; + } + case FIT_MESG_NUM_SLEEP_ASSESSMENT: + { + SleepAssessmentMesg sleepAssessmentMesg(mesg); + for (int i=0; i < (int)sleepAssessmentMesgListeners.size(); i++) + sleepAssessmentMesgListeners[i]->OnMesg(sleepAssessmentMesg); + break; + } + case FIT_MESG_NUM_SLEEP_DISRUPTION_SEVERITY_PERIOD: + { + SleepDisruptionSeverityPeriodMesg sleepDisruptionSeverityPeriodMesg(mesg); + for (int i=0; i < (int)sleepDisruptionSeverityPeriodMesgListeners.size(); i++) + sleepDisruptionSeverityPeriodMesgListeners[i]->OnMesg(sleepDisruptionSeverityPeriodMesg); + break; + } + case FIT_MESG_NUM_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY: + { + SleepDisruptionOvernightSeverityMesg sleepDisruptionOvernightSeverityMesg(mesg); + for (int i=0; i < (int)sleepDisruptionOvernightSeverityMesgListeners.size(); i++) + sleepDisruptionOvernightSeverityMesgListeners[i]->OnMesg(sleepDisruptionOvernightSeverityMesg); + break; + } + case FIT_MESG_NUM_SKIN_TEMP_OVERNIGHT: + { + SkinTempOvernightMesg skinTempOvernightMesg(mesg); + for (int i=0; i < (int)skinTempOvernightMesgListeners.size(); i++) + skinTempOvernightMesgListeners[i]->OnMesg(skinTempOvernightMesg); + break; + } + case FIT_MESG_NUM_PAD: + { + PadMesg padMesg(mesg); + for (int i=0; i < (int)padMesgListeners.size(); i++) + padMesgListeners[i]->OnMesg(padMesg); + break; + } + + default: + break; + } +} + +void MesgBroadcaster::OnMesgDefinition(MesgDefinition& mesgDef) +{ + for (int i=0; i < (int)mesgDefinitionListeners.size(); i++) + mesgDefinitionListeners[i]->OnMesgDefinition(mesgDef); +} + +} // namespace fit + diff --git a/fit_mesg_broadcaster.hpp b/fit_mesg_broadcaster.hpp new file mode 100644 index 0000000..af34d61 --- /dev/null +++ b/fit_mesg_broadcaster.hpp @@ -0,0 +1,546 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_BROADCASTER_HPP) +#define FIT_MESG_BROADCASTER_HPP + +#include +#include +#include "fit_mesg.hpp" +#include "fit_mesg_definition.hpp" +#include "fit_mesg_definition_listener.hpp" +#include "fit_mesg_listener.hpp" +#include "fit_mesg_with_event_broadcaster.hpp" +#include "fit_buffered_record_mesg_broadcaster.hpp" +#include "fit_decode.hpp" +#include "fit_file_id_mesg_listener.hpp" +#include "fit_file_creator_mesg_listener.hpp" +#include "fit_timestamp_correlation_mesg_listener.hpp" +#include "fit_software_mesg_listener.hpp" +#include "fit_slave_device_mesg_listener.hpp" +#include "fit_capabilities_mesg_listener.hpp" +#include "fit_file_capabilities_mesg_listener.hpp" +#include "fit_mesg_capabilities_mesg_listener.hpp" +#include "fit_field_capabilities_mesg_listener.hpp" +#include "fit_device_settings_mesg_listener.hpp" +#include "fit_user_profile_mesg_listener.hpp" +#include "fit_hrm_profile_mesg_listener.hpp" +#include "fit_sdm_profile_mesg_listener.hpp" +#include "fit_bike_profile_mesg_listener.hpp" +#include "fit_connectivity_mesg_listener.hpp" +#include "fit_watchface_settings_mesg_listener.hpp" +#include "fit_ohr_settings_mesg_listener.hpp" +#include "fit_time_in_zone_mesg_listener.hpp" +#include "fit_zones_target_mesg_listener.hpp" +#include "fit_sport_mesg_listener.hpp" +#include "fit_hr_zone_mesg_listener.hpp" +#include "fit_speed_zone_mesg_listener.hpp" +#include "fit_cadence_zone_mesg_listener.hpp" +#include "fit_power_zone_mesg_listener.hpp" +#include "fit_met_zone_mesg_listener.hpp" +#include "fit_training_settings_mesg_listener.hpp" +#include "fit_dive_settings_mesg_listener.hpp" +#include "fit_dive_alarm_mesg_listener.hpp" +#include "fit_dive_apnea_alarm_mesg_listener.hpp" +#include "fit_dive_gas_mesg_listener.hpp" +#include "fit_goal_mesg_listener.hpp" +#include "fit_activity_mesg_listener.hpp" +#include "fit_session_mesg_listener.hpp" +#include "fit_lap_mesg_listener.hpp" +#include "fit_length_mesg_listener.hpp" +#include "fit_record_mesg_listener.hpp" +#include "fit_event_mesg_listener.hpp" +#include "fit_device_info_mesg_listener.hpp" +#include "fit_device_aux_battery_info_mesg_listener.hpp" +#include "fit_training_file_mesg_listener.hpp" +#include "fit_weather_conditions_mesg_listener.hpp" +#include "fit_weather_alert_mesg_listener.hpp" +#include "fit_gps_metadata_mesg_listener.hpp" +#include "fit_camera_event_mesg_listener.hpp" +#include "fit_gyroscope_data_mesg_listener.hpp" +#include "fit_accelerometer_data_mesg_listener.hpp" +#include "fit_magnetometer_data_mesg_listener.hpp" +#include "fit_barometer_data_mesg_listener.hpp" +#include "fit_three_d_sensor_calibration_mesg_listener.hpp" +#include "fit_one_d_sensor_calibration_mesg_listener.hpp" +#include "fit_video_frame_mesg_listener.hpp" +#include "fit_obdii_data_mesg_listener.hpp" +#include "fit_nmea_sentence_mesg_listener.hpp" +#include "fit_aviation_attitude_mesg_listener.hpp" +#include "fit_video_mesg_listener.hpp" +#include "fit_video_title_mesg_listener.hpp" +#include "fit_video_description_mesg_listener.hpp" +#include "fit_video_clip_mesg_listener.hpp" +#include "fit_set_mesg_listener.hpp" +#include "fit_jump_mesg_listener.hpp" +#include "fit_split_mesg_listener.hpp" +#include "fit_split_summary_mesg_listener.hpp" +#include "fit_climb_pro_mesg_listener.hpp" +#include "fit_field_description_mesg_listener.hpp" +#include "fit_developer_data_id_mesg_listener.hpp" +#include "fit_course_mesg_listener.hpp" +#include "fit_course_point_mesg_listener.hpp" +#include "fit_segment_id_mesg_listener.hpp" +#include "fit_segment_leaderboard_entry_mesg_listener.hpp" +#include "fit_segment_point_mesg_listener.hpp" +#include "fit_segment_lap_mesg_listener.hpp" +#include "fit_segment_file_mesg_listener.hpp" +#include "fit_workout_mesg_listener.hpp" +#include "fit_workout_session_mesg_listener.hpp" +#include "fit_workout_step_mesg_listener.hpp" +#include "fit_exercise_title_mesg_listener.hpp" +#include "fit_schedule_mesg_listener.hpp" +#include "fit_totals_mesg_listener.hpp" +#include "fit_weight_scale_mesg_listener.hpp" +#include "fit_blood_pressure_mesg_listener.hpp" +#include "fit_monitoring_info_mesg_listener.hpp" +#include "fit_monitoring_mesg_listener.hpp" +#include "fit_monitoring_hr_data_mesg_listener.hpp" +#include "fit_spo2_data_mesg_listener.hpp" +#include "fit_hr_mesg_listener.hpp" +#include "fit_stress_level_mesg_listener.hpp" +#include "fit_max_met_data_mesg_listener.hpp" +#include "fit_hsa_body_battery_data_mesg_listener.hpp" +#include "fit_hsa_event_mesg_listener.hpp" +#include "fit_hsa_accelerometer_data_mesg_listener.hpp" +#include "fit_hsa_gyroscope_data_mesg_listener.hpp" +#include "fit_hsa_step_data_mesg_listener.hpp" +#include "fit_hsa_spo2_data_mesg_listener.hpp" +#include "fit_hsa_stress_data_mesg_listener.hpp" +#include "fit_hsa_respiration_data_mesg_listener.hpp" +#include "fit_hsa_heart_rate_data_mesg_listener.hpp" +#include "fit_hsa_configuration_data_mesg_listener.hpp" +#include "fit_hsa_wrist_temperature_data_mesg_listener.hpp" +#include "fit_memo_glob_mesg_listener.hpp" +#include "fit_sleep_level_mesg_listener.hpp" +#include "fit_ant_channel_id_mesg_listener.hpp" +#include "fit_ant_rx_mesg_listener.hpp" +#include "fit_ant_tx_mesg_listener.hpp" +#include "fit_exd_screen_configuration_mesg_listener.hpp" +#include "fit_exd_data_field_configuration_mesg_listener.hpp" +#include "fit_exd_data_concept_configuration_mesg_listener.hpp" +#include "fit_dive_summary_mesg_listener.hpp" +#include "fit_aad_accel_features_mesg_listener.hpp" +#include "fit_hrv_mesg_listener.hpp" +#include "fit_beat_intervals_mesg_listener.hpp" +#include "fit_hrv_status_summary_mesg_listener.hpp" +#include "fit_hrv_value_mesg_listener.hpp" +#include "fit_raw_bbi_mesg_listener.hpp" +#include "fit_respiration_rate_mesg_listener.hpp" +#include "fit_chrono_shot_session_mesg_listener.hpp" +#include "fit_chrono_shot_data_mesg_listener.hpp" +#include "fit_tank_update_mesg_listener.hpp" +#include "fit_tank_summary_mesg_listener.hpp" +#include "fit_sleep_assessment_mesg_listener.hpp" +#include "fit_sleep_disruption_severity_period_mesg_listener.hpp" +#include "fit_sleep_disruption_overnight_severity_mesg_listener.hpp" +#include "fit_skin_temp_overnight_mesg_listener.hpp" +#include "fit_pad_mesg_listener.hpp" + +namespace fit +{ + +class MesgBroadcaster : public MesgListener, public MesgDefinitionListener +{ +public: + MesgBroadcaster(void); + FIT_BOOL Run(std::istream& file); + void AddListener(MesgDefinitionListener& mesgDefinitionListener); + void RemoveListener(MesgDefinitionListener& mesgDefinitionListener); + void AddListener(MesgListener& mesgListener); + void RemoveListener(MesgListener& mesgListener); + void AddListener(MesgWithEventListener& mesgListener); + void RemoveListener(MesgWithEventListener& mesgListener); + void AddListener(BufferedRecordMesgListener& bufferedRecordMesgListener); + void RemoveListener(BufferedRecordMesgListener& bufferedRecordMesgListener); + void AddListener(FileIdMesgListener& fileIdMesgListener); + void RemoveListener(FileIdMesgListener& fileIdMesgListener); + void AddListener(FileCreatorMesgListener& fileCreatorMesgListener); + void RemoveListener(FileCreatorMesgListener& fileCreatorMesgListener); + void AddListener(TimestampCorrelationMesgListener& timestampCorrelationMesgListener); + void RemoveListener(TimestampCorrelationMesgListener& timestampCorrelationMesgListener); + void AddListener(SoftwareMesgListener& softwareMesgListener); + void RemoveListener(SoftwareMesgListener& softwareMesgListener); + void AddListener(SlaveDeviceMesgListener& slaveDeviceMesgListener); + void RemoveListener(SlaveDeviceMesgListener& slaveDeviceMesgListener); + void AddListener(CapabilitiesMesgListener& capabilitiesMesgListener); + void RemoveListener(CapabilitiesMesgListener& capabilitiesMesgListener); + void AddListener(FileCapabilitiesMesgListener& fileCapabilitiesMesgListener); + void RemoveListener(FileCapabilitiesMesgListener& fileCapabilitiesMesgListener); + void AddListener(MesgCapabilitiesMesgListener& mesgCapabilitiesMesgListener); + void RemoveListener(MesgCapabilitiesMesgListener& mesgCapabilitiesMesgListener); + void AddListener(FieldCapabilitiesMesgListener& fieldCapabilitiesMesgListener); + void RemoveListener(FieldCapabilitiesMesgListener& fieldCapabilitiesMesgListener); + void AddListener(DeviceSettingsMesgListener& deviceSettingsMesgListener); + void RemoveListener(DeviceSettingsMesgListener& deviceSettingsMesgListener); + void AddListener(UserProfileMesgListener& userProfileMesgListener); + void RemoveListener(UserProfileMesgListener& userProfileMesgListener); + void AddListener(HrmProfileMesgListener& hrmProfileMesgListener); + void RemoveListener(HrmProfileMesgListener& hrmProfileMesgListener); + void AddListener(SdmProfileMesgListener& sdmProfileMesgListener); + void RemoveListener(SdmProfileMesgListener& sdmProfileMesgListener); + void AddListener(BikeProfileMesgListener& bikeProfileMesgListener); + void RemoveListener(BikeProfileMesgListener& bikeProfileMesgListener); + void AddListener(ConnectivityMesgListener& connectivityMesgListener); + void RemoveListener(ConnectivityMesgListener& connectivityMesgListener); + void AddListener(WatchfaceSettingsMesgListener& watchfaceSettingsMesgListener); + void RemoveListener(WatchfaceSettingsMesgListener& watchfaceSettingsMesgListener); + void AddListener(OhrSettingsMesgListener& ohrSettingsMesgListener); + void RemoveListener(OhrSettingsMesgListener& ohrSettingsMesgListener); + void AddListener(TimeInZoneMesgListener& timeInZoneMesgListener); + void RemoveListener(TimeInZoneMesgListener& timeInZoneMesgListener); + void AddListener(ZonesTargetMesgListener& zonesTargetMesgListener); + void RemoveListener(ZonesTargetMesgListener& zonesTargetMesgListener); + void AddListener(SportMesgListener& sportMesgListener); + void RemoveListener(SportMesgListener& sportMesgListener); + void AddListener(HrZoneMesgListener& hrZoneMesgListener); + void RemoveListener(HrZoneMesgListener& hrZoneMesgListener); + void AddListener(SpeedZoneMesgListener& speedZoneMesgListener); + void RemoveListener(SpeedZoneMesgListener& speedZoneMesgListener); + void AddListener(CadenceZoneMesgListener& cadenceZoneMesgListener); + void RemoveListener(CadenceZoneMesgListener& cadenceZoneMesgListener); + void AddListener(PowerZoneMesgListener& powerZoneMesgListener); + void RemoveListener(PowerZoneMesgListener& powerZoneMesgListener); + void AddListener(MetZoneMesgListener& metZoneMesgListener); + void RemoveListener(MetZoneMesgListener& metZoneMesgListener); + void AddListener(TrainingSettingsMesgListener& trainingSettingsMesgListener); + void RemoveListener(TrainingSettingsMesgListener& trainingSettingsMesgListener); + void AddListener(DiveSettingsMesgListener& diveSettingsMesgListener); + void RemoveListener(DiveSettingsMesgListener& diveSettingsMesgListener); + void AddListener(DiveAlarmMesgListener& diveAlarmMesgListener); + void RemoveListener(DiveAlarmMesgListener& diveAlarmMesgListener); + void AddListener(DiveApneaAlarmMesgListener& diveApneaAlarmMesgListener); + void RemoveListener(DiveApneaAlarmMesgListener& diveApneaAlarmMesgListener); + void AddListener(DiveGasMesgListener& diveGasMesgListener); + void RemoveListener(DiveGasMesgListener& diveGasMesgListener); + void AddListener(GoalMesgListener& goalMesgListener); + void RemoveListener(GoalMesgListener& goalMesgListener); + void AddListener(ActivityMesgListener& activityMesgListener); + void RemoveListener(ActivityMesgListener& activityMesgListener); + void AddListener(SessionMesgListener& sessionMesgListener); + void RemoveListener(SessionMesgListener& sessionMesgListener); + void AddListener(LapMesgListener& lapMesgListener); + void RemoveListener(LapMesgListener& lapMesgListener); + void AddListener(LengthMesgListener& lengthMesgListener); + void RemoveListener(LengthMesgListener& lengthMesgListener); + void AddListener(RecordMesgListener& recordMesgListener); + void RemoveListener(RecordMesgListener& recordMesgListener); + void AddListener(EventMesgListener& eventMesgListener); + void RemoveListener(EventMesgListener& eventMesgListener); + void AddListener(DeviceInfoMesgListener& deviceInfoMesgListener); + void RemoveListener(DeviceInfoMesgListener& deviceInfoMesgListener); + void AddListener(DeviceAuxBatteryInfoMesgListener& deviceAuxBatteryInfoMesgListener); + void RemoveListener(DeviceAuxBatteryInfoMesgListener& deviceAuxBatteryInfoMesgListener); + void AddListener(TrainingFileMesgListener& trainingFileMesgListener); + void RemoveListener(TrainingFileMesgListener& trainingFileMesgListener); + void AddListener(WeatherConditionsMesgListener& weatherConditionsMesgListener); + void RemoveListener(WeatherConditionsMesgListener& weatherConditionsMesgListener); + void AddListener(WeatherAlertMesgListener& weatherAlertMesgListener); + void RemoveListener(WeatherAlertMesgListener& weatherAlertMesgListener); + void AddListener(GpsMetadataMesgListener& gpsMetadataMesgListener); + void RemoveListener(GpsMetadataMesgListener& gpsMetadataMesgListener); + void AddListener(CameraEventMesgListener& cameraEventMesgListener); + void RemoveListener(CameraEventMesgListener& cameraEventMesgListener); + void AddListener(GyroscopeDataMesgListener& gyroscopeDataMesgListener); + void RemoveListener(GyroscopeDataMesgListener& gyroscopeDataMesgListener); + void AddListener(AccelerometerDataMesgListener& accelerometerDataMesgListener); + void RemoveListener(AccelerometerDataMesgListener& accelerometerDataMesgListener); + void AddListener(MagnetometerDataMesgListener& magnetometerDataMesgListener); + void RemoveListener(MagnetometerDataMesgListener& magnetometerDataMesgListener); + void AddListener(BarometerDataMesgListener& barometerDataMesgListener); + void RemoveListener(BarometerDataMesgListener& barometerDataMesgListener); + void AddListener(ThreeDSensorCalibrationMesgListener& threeDSensorCalibrationMesgListener); + void RemoveListener(ThreeDSensorCalibrationMesgListener& threeDSensorCalibrationMesgListener); + void AddListener(OneDSensorCalibrationMesgListener& oneDSensorCalibrationMesgListener); + void RemoveListener(OneDSensorCalibrationMesgListener& oneDSensorCalibrationMesgListener); + void AddListener(VideoFrameMesgListener& videoFrameMesgListener); + void RemoveListener(VideoFrameMesgListener& videoFrameMesgListener); + void AddListener(ObdiiDataMesgListener& obdiiDataMesgListener); + void RemoveListener(ObdiiDataMesgListener& obdiiDataMesgListener); + void AddListener(NmeaSentenceMesgListener& nmeaSentenceMesgListener); + void RemoveListener(NmeaSentenceMesgListener& nmeaSentenceMesgListener); + void AddListener(AviationAttitudeMesgListener& aviationAttitudeMesgListener); + void RemoveListener(AviationAttitudeMesgListener& aviationAttitudeMesgListener); + void AddListener(VideoMesgListener& videoMesgListener); + void RemoveListener(VideoMesgListener& videoMesgListener); + void AddListener(VideoTitleMesgListener& videoTitleMesgListener); + void RemoveListener(VideoTitleMesgListener& videoTitleMesgListener); + void AddListener(VideoDescriptionMesgListener& videoDescriptionMesgListener); + void RemoveListener(VideoDescriptionMesgListener& videoDescriptionMesgListener); + void AddListener(VideoClipMesgListener& videoClipMesgListener); + void RemoveListener(VideoClipMesgListener& videoClipMesgListener); + void AddListener(SetMesgListener& setMesgListener); + void RemoveListener(SetMesgListener& setMesgListener); + void AddListener(JumpMesgListener& jumpMesgListener); + void RemoveListener(JumpMesgListener& jumpMesgListener); + void AddListener(SplitMesgListener& splitMesgListener); + void RemoveListener(SplitMesgListener& splitMesgListener); + void AddListener(SplitSummaryMesgListener& splitSummaryMesgListener); + void RemoveListener(SplitSummaryMesgListener& splitSummaryMesgListener); + void AddListener(ClimbProMesgListener& climbProMesgListener); + void RemoveListener(ClimbProMesgListener& climbProMesgListener); + void AddListener(FieldDescriptionMesgListener& fieldDescriptionMesgListener); + void RemoveListener(FieldDescriptionMesgListener& fieldDescriptionMesgListener); + void AddListener(DeveloperDataIdMesgListener& developerDataIdMesgListener); + void RemoveListener(DeveloperDataIdMesgListener& developerDataIdMesgListener); + void AddListener(CourseMesgListener& courseMesgListener); + void RemoveListener(CourseMesgListener& courseMesgListener); + void AddListener(CoursePointMesgListener& coursePointMesgListener); + void RemoveListener(CoursePointMesgListener& coursePointMesgListener); + void AddListener(SegmentIdMesgListener& segmentIdMesgListener); + void RemoveListener(SegmentIdMesgListener& segmentIdMesgListener); + void AddListener(SegmentLeaderboardEntryMesgListener& segmentLeaderboardEntryMesgListener); + void RemoveListener(SegmentLeaderboardEntryMesgListener& segmentLeaderboardEntryMesgListener); + void AddListener(SegmentPointMesgListener& segmentPointMesgListener); + void RemoveListener(SegmentPointMesgListener& segmentPointMesgListener); + void AddListener(SegmentLapMesgListener& segmentLapMesgListener); + void RemoveListener(SegmentLapMesgListener& segmentLapMesgListener); + void AddListener(SegmentFileMesgListener& segmentFileMesgListener); + void RemoveListener(SegmentFileMesgListener& segmentFileMesgListener); + void AddListener(WorkoutMesgListener& workoutMesgListener); + void RemoveListener(WorkoutMesgListener& workoutMesgListener); + void AddListener(WorkoutSessionMesgListener& workoutSessionMesgListener); + void RemoveListener(WorkoutSessionMesgListener& workoutSessionMesgListener); + void AddListener(WorkoutStepMesgListener& workoutStepMesgListener); + void RemoveListener(WorkoutStepMesgListener& workoutStepMesgListener); + void AddListener(ExerciseTitleMesgListener& exerciseTitleMesgListener); + void RemoveListener(ExerciseTitleMesgListener& exerciseTitleMesgListener); + void AddListener(ScheduleMesgListener& scheduleMesgListener); + void RemoveListener(ScheduleMesgListener& scheduleMesgListener); + void AddListener(TotalsMesgListener& totalsMesgListener); + void RemoveListener(TotalsMesgListener& totalsMesgListener); + void AddListener(WeightScaleMesgListener& weightScaleMesgListener); + void RemoveListener(WeightScaleMesgListener& weightScaleMesgListener); + void AddListener(BloodPressureMesgListener& bloodPressureMesgListener); + void RemoveListener(BloodPressureMesgListener& bloodPressureMesgListener); + void AddListener(MonitoringInfoMesgListener& monitoringInfoMesgListener); + void RemoveListener(MonitoringInfoMesgListener& monitoringInfoMesgListener); + void AddListener(MonitoringMesgListener& monitoringMesgListener); + void RemoveListener(MonitoringMesgListener& monitoringMesgListener); + void AddListener(MonitoringHrDataMesgListener& monitoringHrDataMesgListener); + void RemoveListener(MonitoringHrDataMesgListener& monitoringHrDataMesgListener); + void AddListener(Spo2DataMesgListener& spo2DataMesgListener); + void RemoveListener(Spo2DataMesgListener& spo2DataMesgListener); + void AddListener(HrMesgListener& hrMesgListener); + void RemoveListener(HrMesgListener& hrMesgListener); + void AddListener(StressLevelMesgListener& stressLevelMesgListener); + void RemoveListener(StressLevelMesgListener& stressLevelMesgListener); + void AddListener(MaxMetDataMesgListener& maxMetDataMesgListener); + void RemoveListener(MaxMetDataMesgListener& maxMetDataMesgListener); + void AddListener(HsaBodyBatteryDataMesgListener& hsaBodyBatteryDataMesgListener); + void RemoveListener(HsaBodyBatteryDataMesgListener& hsaBodyBatteryDataMesgListener); + void AddListener(HsaEventMesgListener& hsaEventMesgListener); + void RemoveListener(HsaEventMesgListener& hsaEventMesgListener); + void AddListener(HsaAccelerometerDataMesgListener& hsaAccelerometerDataMesgListener); + void RemoveListener(HsaAccelerometerDataMesgListener& hsaAccelerometerDataMesgListener); + void AddListener(HsaGyroscopeDataMesgListener& hsaGyroscopeDataMesgListener); + void RemoveListener(HsaGyroscopeDataMesgListener& hsaGyroscopeDataMesgListener); + void AddListener(HsaStepDataMesgListener& hsaStepDataMesgListener); + void RemoveListener(HsaStepDataMesgListener& hsaStepDataMesgListener); + void AddListener(HsaSpo2DataMesgListener& hsaSpo2DataMesgListener); + void RemoveListener(HsaSpo2DataMesgListener& hsaSpo2DataMesgListener); + void AddListener(HsaStressDataMesgListener& hsaStressDataMesgListener); + void RemoveListener(HsaStressDataMesgListener& hsaStressDataMesgListener); + void AddListener(HsaRespirationDataMesgListener& hsaRespirationDataMesgListener); + void RemoveListener(HsaRespirationDataMesgListener& hsaRespirationDataMesgListener); + void AddListener(HsaHeartRateDataMesgListener& hsaHeartRateDataMesgListener); + void RemoveListener(HsaHeartRateDataMesgListener& hsaHeartRateDataMesgListener); + void AddListener(HsaConfigurationDataMesgListener& hsaConfigurationDataMesgListener); + void RemoveListener(HsaConfigurationDataMesgListener& hsaConfigurationDataMesgListener); + void AddListener(HsaWristTemperatureDataMesgListener& hsaWristTemperatureDataMesgListener); + void RemoveListener(HsaWristTemperatureDataMesgListener& hsaWristTemperatureDataMesgListener); + void AddListener(MemoGlobMesgListener& memoGlobMesgListener); + void RemoveListener(MemoGlobMesgListener& memoGlobMesgListener); + void AddListener(SleepLevelMesgListener& sleepLevelMesgListener); + void RemoveListener(SleepLevelMesgListener& sleepLevelMesgListener); + void AddListener(AntChannelIdMesgListener& antChannelIdMesgListener); + void RemoveListener(AntChannelIdMesgListener& antChannelIdMesgListener); + void AddListener(AntRxMesgListener& antRxMesgListener); + void RemoveListener(AntRxMesgListener& antRxMesgListener); + void AddListener(AntTxMesgListener& antTxMesgListener); + void RemoveListener(AntTxMesgListener& antTxMesgListener); + void AddListener(ExdScreenConfigurationMesgListener& exdScreenConfigurationMesgListener); + void RemoveListener(ExdScreenConfigurationMesgListener& exdScreenConfigurationMesgListener); + void AddListener(ExdDataFieldConfigurationMesgListener& exdDataFieldConfigurationMesgListener); + void RemoveListener(ExdDataFieldConfigurationMesgListener& exdDataFieldConfigurationMesgListener); + void AddListener(ExdDataConceptConfigurationMesgListener& exdDataConceptConfigurationMesgListener); + void RemoveListener(ExdDataConceptConfigurationMesgListener& exdDataConceptConfigurationMesgListener); + void AddListener(DiveSummaryMesgListener& diveSummaryMesgListener); + void RemoveListener(DiveSummaryMesgListener& diveSummaryMesgListener); + void AddListener(AadAccelFeaturesMesgListener& aadAccelFeaturesMesgListener); + void RemoveListener(AadAccelFeaturesMesgListener& aadAccelFeaturesMesgListener); + void AddListener(HrvMesgListener& hrvMesgListener); + void RemoveListener(HrvMesgListener& hrvMesgListener); + void AddListener(BeatIntervalsMesgListener& beatIntervalsMesgListener); + void RemoveListener(BeatIntervalsMesgListener& beatIntervalsMesgListener); + void AddListener(HrvStatusSummaryMesgListener& hrvStatusSummaryMesgListener); + void RemoveListener(HrvStatusSummaryMesgListener& hrvStatusSummaryMesgListener); + void AddListener(HrvValueMesgListener& hrvValueMesgListener); + void RemoveListener(HrvValueMesgListener& hrvValueMesgListener); + void AddListener(RawBbiMesgListener& rawBbiMesgListener); + void RemoveListener(RawBbiMesgListener& rawBbiMesgListener); + void AddListener(RespirationRateMesgListener& respirationRateMesgListener); + void RemoveListener(RespirationRateMesgListener& respirationRateMesgListener); + void AddListener(ChronoShotSessionMesgListener& chronoShotSessionMesgListener); + void RemoveListener(ChronoShotSessionMesgListener& chronoShotSessionMesgListener); + void AddListener(ChronoShotDataMesgListener& chronoShotDataMesgListener); + void RemoveListener(ChronoShotDataMesgListener& chronoShotDataMesgListener); + void AddListener(TankUpdateMesgListener& tankUpdateMesgListener); + void RemoveListener(TankUpdateMesgListener& tankUpdateMesgListener); + void AddListener(TankSummaryMesgListener& tankSummaryMesgListener); + void RemoveListener(TankSummaryMesgListener& tankSummaryMesgListener); + void AddListener(SleepAssessmentMesgListener& sleepAssessmentMesgListener); + void RemoveListener(SleepAssessmentMesgListener& sleepAssessmentMesgListener); + void AddListener(SleepDisruptionSeverityPeriodMesgListener& sleepDisruptionSeverityPeriodMesgListener); + void RemoveListener(SleepDisruptionSeverityPeriodMesgListener& sleepDisruptionSeverityPeriodMesgListener); + void AddListener(SleepDisruptionOvernightSeverityMesgListener& sleepDisruptionOvernightSeverityMesgListener); + void RemoveListener(SleepDisruptionOvernightSeverityMesgListener& sleepDisruptionOvernightSeverityMesgListener); + void AddListener(SkinTempOvernightMesgListener& skinTempOvernightMesgListener); + void RemoveListener(SkinTempOvernightMesgListener& skinTempOvernightMesgListener); + void AddListener(PadMesgListener& padMesgListener); + void RemoveListener(PadMesgListener& padMesgListener); + void OnMesg(Mesg& mesg); + void OnMesgDefinition(MesgDefinition& mesgDef); + +private: + MesgWithEventBroadcaster mesgWithEventBroadcaster; + BufferedRecordMesgBroadcaster bufferedRecordMesgBroadcaster; + std::vector mesgDefinitionListeners; + std::vector mesgListeners; + std::vector fileIdMesgListeners; + std::vector fileCreatorMesgListeners; + std::vector timestampCorrelationMesgListeners; + std::vector softwareMesgListeners; + std::vector slaveDeviceMesgListeners; + std::vector capabilitiesMesgListeners; + std::vector fileCapabilitiesMesgListeners; + std::vector mesgCapabilitiesMesgListeners; + std::vector fieldCapabilitiesMesgListeners; + std::vector deviceSettingsMesgListeners; + std::vector userProfileMesgListeners; + std::vector hrmProfileMesgListeners; + std::vector sdmProfileMesgListeners; + std::vector bikeProfileMesgListeners; + std::vector connectivityMesgListeners; + std::vector watchfaceSettingsMesgListeners; + std::vector ohrSettingsMesgListeners; + std::vector timeInZoneMesgListeners; + std::vector zonesTargetMesgListeners; + std::vector sportMesgListeners; + std::vector hrZoneMesgListeners; + std::vector speedZoneMesgListeners; + std::vector cadenceZoneMesgListeners; + std::vector powerZoneMesgListeners; + std::vector metZoneMesgListeners; + std::vector trainingSettingsMesgListeners; + std::vector diveSettingsMesgListeners; + std::vector diveAlarmMesgListeners; + std::vector diveApneaAlarmMesgListeners; + std::vector diveGasMesgListeners; + std::vector goalMesgListeners; + std::vector activityMesgListeners; + std::vector sessionMesgListeners; + std::vector lapMesgListeners; + std::vector lengthMesgListeners; + std::vector recordMesgListeners; + std::vector eventMesgListeners; + std::vector deviceInfoMesgListeners; + std::vector deviceAuxBatteryInfoMesgListeners; + std::vector trainingFileMesgListeners; + std::vector weatherConditionsMesgListeners; + std::vector weatherAlertMesgListeners; + std::vector gpsMetadataMesgListeners; + std::vector cameraEventMesgListeners; + std::vector gyroscopeDataMesgListeners; + std::vector accelerometerDataMesgListeners; + std::vector magnetometerDataMesgListeners; + std::vector barometerDataMesgListeners; + std::vector threeDSensorCalibrationMesgListeners; + std::vector oneDSensorCalibrationMesgListeners; + std::vector videoFrameMesgListeners; + std::vector obdiiDataMesgListeners; + std::vector nmeaSentenceMesgListeners; + std::vector aviationAttitudeMesgListeners; + std::vector videoMesgListeners; + std::vector videoTitleMesgListeners; + std::vector videoDescriptionMesgListeners; + std::vector videoClipMesgListeners; + std::vector setMesgListeners; + std::vector jumpMesgListeners; + std::vector splitMesgListeners; + std::vector splitSummaryMesgListeners; + std::vector climbProMesgListeners; + std::vector fieldDescriptionMesgListeners; + std::vector developerDataIdMesgListeners; + std::vector courseMesgListeners; + std::vector coursePointMesgListeners; + std::vector segmentIdMesgListeners; + std::vector segmentLeaderboardEntryMesgListeners; + std::vector segmentPointMesgListeners; + std::vector segmentLapMesgListeners; + std::vector segmentFileMesgListeners; + std::vector workoutMesgListeners; + std::vector workoutSessionMesgListeners; + std::vector workoutStepMesgListeners; + std::vector exerciseTitleMesgListeners; + std::vector scheduleMesgListeners; + std::vector totalsMesgListeners; + std::vector weightScaleMesgListeners; + std::vector bloodPressureMesgListeners; + std::vector monitoringInfoMesgListeners; + std::vector monitoringMesgListeners; + std::vector monitoringHrDataMesgListeners; + std::vector spo2DataMesgListeners; + std::vector hrMesgListeners; + std::vector stressLevelMesgListeners; + std::vector maxMetDataMesgListeners; + std::vector hsaBodyBatteryDataMesgListeners; + std::vector hsaEventMesgListeners; + std::vector hsaAccelerometerDataMesgListeners; + std::vector hsaGyroscopeDataMesgListeners; + std::vector hsaStepDataMesgListeners; + std::vector hsaSpo2DataMesgListeners; + std::vector hsaStressDataMesgListeners; + std::vector hsaRespirationDataMesgListeners; + std::vector hsaHeartRateDataMesgListeners; + std::vector hsaConfigurationDataMesgListeners; + std::vector hsaWristTemperatureDataMesgListeners; + std::vector memoGlobMesgListeners; + std::vector sleepLevelMesgListeners; + std::vector antChannelIdMesgListeners; + std::vector antRxMesgListeners; + std::vector antTxMesgListeners; + std::vector exdScreenConfigurationMesgListeners; + std::vector exdDataFieldConfigurationMesgListeners; + std::vector exdDataConceptConfigurationMesgListeners; + std::vector diveSummaryMesgListeners; + std::vector aadAccelFeaturesMesgListeners; + std::vector hrvMesgListeners; + std::vector beatIntervalsMesgListeners; + std::vector hrvStatusSummaryMesgListeners; + std::vector hrvValueMesgListeners; + std::vector rawBbiMesgListeners; + std::vector respirationRateMesgListeners; + std::vector chronoShotSessionMesgListeners; + std::vector chronoShotDataMesgListeners; + std::vector tankUpdateMesgListeners; + std::vector tankSummaryMesgListeners; + std::vector sleepAssessmentMesgListeners; + std::vector sleepDisruptionSeverityPeriodMesgListeners; + std::vector sleepDisruptionOvernightSeverityMesgListeners; + std::vector skinTempOvernightMesgListeners; + std::vector padMesgListeners; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_BROADCASTER_HPP) diff --git a/fit_mesg_capabilities_mesg.hpp b/fit_mesg_capabilities_mesg.hpp new file mode 100644 index 0000000..d9bd761 --- /dev/null +++ b/fit_mesg_capabilities_mesg.hpp @@ -0,0 +1,313 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_CAPABILITIES_MESG_HPP) +#define FIT_MESG_CAPABILITIES_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MesgCapabilitiesMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 File = 0; + static const FIT_UINT8 MesgNum = 1; + static const FIT_UINT8 CountType = 2; + static const FIT_UINT8 Count = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MesgCapabilitiesMesg(void) : Mesg(Profile::MESG_MESG_CAPABILITIES) + { + } + + MesgCapabilitiesMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of file field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFileValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns file field + /////////////////////////////////////////////////////////////////////// + FIT_FILE GetFile(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set file field + /////////////////////////////////////////////////////////////////////// + void SetFile(FIT_FILE file) + { + SetFieldENUMValue(0, file, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mesg_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMesgNumValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mesg_num field + /////////////////////////////////////////////////////////////////////// + FIT_MESG_NUM GetMesgNum(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mesg_num field + /////////////////////////////////////////////////////////////////////// + void SetMesgNum(FIT_MESG_NUM mesgNum) + { + SetFieldUINT16Value(1, mesgNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of count_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCountTypeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns count_type field + /////////////////////////////////////////////////////////////////////// + FIT_MESG_COUNT GetCountType(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set count_type field + /////////////////////////////////////////////////////////////////////// + void SetCountType(FIT_MESG_COUNT countType) + { + SetFieldENUMValue(2, countType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCountValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCount(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set count field + /////////////////////////////////////////////////////////////////////// + void SetCount(FIT_UINT16 count) + { + SetFieldUINT16Value(3, count, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_per_file field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumPerFileValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_NUM_PER_FILE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_NUM_PER_FILE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns num_per_file field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumPerFile(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_NUM_PER_FILE); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_per_file field + /////////////////////////////////////////////////////////////////////// + void SetNumPerFile(FIT_UINT16 numPerFile) + { + SetFieldUINT16Value(3, numPerFile, 0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_NUM_PER_FILE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_per_file field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPerFileValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns max_per_file field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPerFile(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_per_file field + /////////////////////////////////////////////////////////////////////// + void SetMaxPerFile(FIT_UINT16 maxPerFile) + { + SetFieldUINT16Value(3, maxPerFile, 0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_per_file_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPerFileTypeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns max_per_file_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPerFileType(void) const + { + return GetFieldUINT16Value(3, 0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_per_file_type field + /////////////////////////////////////////////////////////////////////// + void SetMaxPerFileType(FIT_UINT16 maxPerFileType) + { + SetFieldUINT16Value(3, maxPerFileType, 0, (FIT_UINT16) Profile::MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE_TYPE); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_CAPABILITIES_MESG_HPP) diff --git a/fit_mesg_capabilities_mesg_listener.hpp b/fit_mesg_capabilities_mesg_listener.hpp new file mode 100644 index 0000000..f05e84a --- /dev/null +++ b/fit_mesg_capabilities_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_CAPABILITIES_MESG_LISTENER_HPP) +#define FIT_MESG_CAPABILITIES_MESG_LISTENER_HPP + +#include "fit_mesg_capabilities_mesg.hpp" + +namespace fit +{ + +class MesgCapabilitiesMesgListener +{ +public: + virtual ~MesgCapabilitiesMesgListener() {} + virtual void OnMesg(MesgCapabilitiesMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_CAPABILITIES_MESG_LISTENER_HPP) diff --git a/fit_mesg_definition.cpp b/fit_mesg_definition.cpp new file mode 100644 index 0000000..7e9d94f --- /dev/null +++ b/fit_mesg_definition.cpp @@ -0,0 +1,299 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include "fit_mesg_definition.hpp" +#include "fit_developer_field_definition.hpp" + +namespace fit +{ + +MesgDefinition::MesgDefinition(void) + : num(FIT_MESG_NUM_INVALID) + , localNum(0) + , fields() + , devFields() +{ +} + +MesgDefinition::MesgDefinition(const Mesg& mesg) + : num(mesg.GetNum()) + , localNum(mesg.GetLocalNum()) +{ + for (FIT_UINT16 i=0; i < (FIT_UINT16)mesg.GetNumFields(); i++) + fields.push_back(FieldDefinition(mesg.GetFieldByIndex(i))); + + for ( auto field : mesg.GetDeveloperFields() ) + { + devFields.push_back( DeveloperFieldDefinition(field) ); + } +} + +FIT_UINT16 MesgDefinition::GetNum() const +{ + return num; +} + +FIT_UINT8 MesgDefinition::GetLocalNum() const +{ + return localNum; +} + +void MesgDefinition::SetNum(const FIT_UINT16 newNum) +{ + num = newNum; +} + +void MesgDefinition::SetLocalNum(const FIT_UINT8 newLocalNum) +{ + localNum = newLocalNum; +} + +void MesgDefinition::AddField(const FieldDefinition& fieldDef) +{ + fields.push_back(fieldDef); +} + +void MesgDefinition::AddDevField(const DeveloperFieldDefinition& fieldDef) +{ + devFields.push_back(fieldDef); +} + +void MesgDefinition::ClearFields() +{ + fields.clear(); + devFields.clear(); +} + +int MesgDefinition::GetNumFields() const +{ + return ((int) fields.size()); +} + +int MesgDefinition::GetNumDevFields() const +{ + return ((int) devFields.size()); +} + +std::vector& MesgDefinition::GetFields() +{ + return fields; +} + +std::vector& MesgDefinition::GetDevFields() +{ + return devFields; +} + +FieldDefinition* MesgDefinition::GetField(const FIT_UINT8 fieldNum) +{ + for (int i=0; i<(int)fields.size(); i++) + { + if (fieldNum == fields[i].GetNum()) + return &(fields[i]); + } + + return FIT_NULL; +} + +FieldDefinition* MesgDefinition::GetFieldByIndex(const FIT_UINT16 index) +{ + if (index < fields.size()) + return &(fields[index]); + + return FIT_NULL; +} + +DeveloperFieldDefinition* MesgDefinition::GetDevFieldByIndex(const FIT_UINT16 index) +{ + if (index < devFields.size()) + return &devFields[index]; + + return FIT_NULL; +} + +const std::vector& MesgDefinition::GetFields() const +{ + return fields; +} + +const std::vector& MesgDefinition::GetDevFields() const +{ + return devFields; +} + +const FieldDefinition* MesgDefinition::GetField(const FIT_UINT8 fieldNum) const +{ + for (int i=0; i<(int)fields.size(); i++) + { + if (fieldNum == fields[i].GetNum()) + return &(fields[i]); + } + + return FIT_NULL; +} + +const FieldDefinition* MesgDefinition::GetFieldByIndex(const FIT_UINT16 index) const +{ + if (index < fields.size()) + return &(fields[index]); + + return FIT_NULL; +} + +const DeveloperFieldDefinition* MesgDefinition::GetDevFieldByIndex(const FIT_UINT16 index) const +{ + if (index < devFields.size()) + return &devFields[index]; + + return FIT_NULL; +} + +FIT_BOOL MesgDefinition::operator==(const MesgDefinition& mesgDef) const +{ + if (num != mesgDef.num) + return FIT_FALSE; + + if (localNum != mesgDef.localNum) + return FIT_FALSE; + + if (fields.size() != mesgDef.fields.size()) + return FIT_FALSE; + + for (int i=0; i<(int)fields.size(); i++) + { + if (fields[i] != mesgDef.fields[i]) + return FIT_FALSE; + } + + return FIT_TRUE; +} + +FIT_BOOL MesgDefinition::operator!=(const MesgDefinition& mesgDef) const +{ + return !(*this == mesgDef); +} + +FIT_BOOL MesgDefinition::Supports(const Mesg& mesg) const +{ + return Supports(MesgDefinition(mesg)); +} + +FIT_BOOL MesgDefinition::Supports(const MesgDefinition& mesgDef) const +{ + if (num != mesgDef.num) + return FIT_FALSE; + + if (localNum != mesgDef.localNum) + return FIT_FALSE; + + for (int i=0; i<(int)mesgDef.fields.size(); i++) + { + const FieldDefinition* supportedFieldDef = GetField(mesgDef.fields[i].GetNum()); + + if (supportedFieldDef == FIT_NULL) // Could not find field with matching number. + return FIT_FALSE; + + if (mesgDef.fields[i].GetSize() > supportedFieldDef->GetSize()) // Other field definition is larger than this field definition. + return FIT_FALSE; + } + + // Check to make sure that all field developer fields are defined + for (int i=0; i<(int)mesgDef.devFields.size(); i++) + { + const DeveloperFieldDefinition fieldDef = mesgDef.devFields[i]; + const DeveloperFieldDefinition* supportedDef = GetDevField(fieldDef.GetDeveloperDataIndex(), fieldDef.GetNum()); + + // There is a Field Definition that we don't have a description for + if (supportedDef == FIT_NULL) + return FIT_FALSE; + + // The definition is a larger size that we dont support + if (fieldDef.GetSize() > supportedDef->GetSize()) + return FIT_FALSE; + } + + return FIT_TRUE; +} + +const DeveloperFieldDefinition* MesgDefinition::GetDevField(const FIT_UINT8 developerIndex, const FIT_UINT8 num) const +{ + for (int i=0; i<(int)devFields.size(); i++) + { + if ((devFields[i].GetNum() == num) && (devFields[i].GetDeveloperDataIndex() == developerIndex)) + return &(devFields[i]); + } + return FIT_NULL; +} + +int MesgDefinition::Write(std::ostream &file) const +{ + int mesgSize = 6; + + if ( devFields.size() > 0 ) + { + file.put( ( FIT_HDR_TYPE_DEF_BIT | FIT_HDR_DEV_FIELD_BIT ) | ( localNum & FIT_HDR_TYPE_MASK ) ); // Message definition record header with local message number. + } + else + { + file.put((FIT_HDR_TYPE_DEF_BIT) | (localNum & FIT_HDR_TYPE_MASK)); // Message definition record header with local message number. + } + file.put(0); // Reserved + file.put(GetArch()); + if (GetArch()) + { // Big Endian + file.put((FIT_UINT8)(num >> 8)); + file.put((FIT_UINT8)num); + } + else + { + file.put((FIT_UINT8)num); + file.put((FIT_UINT8)(num >> 8)); + } + file.put((FIT_UINT8)fields.size()); + + for (FIT_UINT8 i=0; i 0 ) + { + file.put( ( FIT_UINT8 )devFields.size() ); + mesgSize += 1; + } + for ( FIT_UINT8 i = 0; i < devFields.size(); i++ ) + { + int fieldSize = devFields[i].Write( file ); + mesgSize += fieldSize; + } + return mesgSize; +} + +int MesgDefinition::GetDeveloperFieldTotalSize() const +{ + int totalSize = 0; + + for (int i = 0; i < (int)devFields.size(); i++) + { + totalSize += devFields[i].GetSize(); + } + + return totalSize; +} + +} // namespace fit diff --git a/fit_mesg_definition.hpp b/fit_mesg_definition.hpp new file mode 100644 index 0000000..d0afbad --- /dev/null +++ b/fit_mesg_definition.hpp @@ -0,0 +1,67 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_DEFINITION_HPP) +#define FIT_MESG_DEFINITION_HPP + +#include +#include +#include "fit.hpp" +#include "fit_field_definition.hpp" +#include "fit_developer_field_definition.hpp" +#include "fit_mesg.hpp" + +namespace fit +{ + +class MesgDefinition +{ +public: + MesgDefinition(); + MesgDefinition(const Mesg& mesg); + FIT_UINT16 GetNum() const; + FIT_UINT8 GetLocalNum() const; + void SetNum(const FIT_UINT16 newNum); + void SetLocalNum(const FIT_UINT8 newLocalNum); + void AddField(const FieldDefinition& fieldDef); + void AddDevField(const DeveloperFieldDefinition& fieldDef); + void ClearFields(); + int GetNumFields() const; + int GetNumDevFields() const; + std::vector& GetFields(); + std::vector& GetDevFields(); + FieldDefinition* GetField(const FIT_UINT8 fieldNum); + FieldDefinition* GetFieldByIndex(const FIT_UINT16 index); + DeveloperFieldDefinition* GetDevFieldByIndex(const FIT_UINT16 index); + const std::vector& GetFields() const; + const std::vector& GetDevFields() const; + const FieldDefinition* GetField(const FIT_UINT8 fieldNum) const; + const FieldDefinition* GetFieldByIndex(const FIT_UINT16 index) const; + const DeveloperFieldDefinition* GetDevFieldByIndex(const FIT_UINT16 index) const; + FIT_BOOL operator==(const MesgDefinition& mesgDef) const; + FIT_BOOL operator!=(const MesgDefinition& mesgDef) const; + FIT_BOOL Supports(const Mesg& mesg) const; + FIT_BOOL Supports(const MesgDefinition& mesgDef) const; + const DeveloperFieldDefinition* GetDevField(const FIT_UINT8 developerIndex, const FIT_UINT8 num) const; + int Write(std::ostream &file) const; + int GetDeveloperFieldTotalSize() const; + +private: + FIT_UINT16 num; + FIT_UINT8 localNum; + std::vector fields; + std::vector devFields; +}; + +} // namespace fit + +#endif // defined(FIT_MESG_DEFINITION_HPP) diff --git a/fit_mesg_definition_listener.hpp b/fit_mesg_definition_listener.hpp new file mode 100644 index 0000000..45db9c8 --- /dev/null +++ b/fit_mesg_definition_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_DEFINITION_LISTENER_HPP) +#define FIT_MESG_DEFINITION_LISTENER_HPP + +#include "fit_mesg_definition.hpp" + +namespace fit +{ + +class MesgDefinitionListener +{ +public: + virtual ~MesgDefinitionListener() {} + virtual void OnMesgDefinition(MesgDefinition& mesgDef) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_DEFINITION_LISTENER_HPP) diff --git a/fit_mesg_listener.hpp b/fit_mesg_listener.hpp new file mode 100644 index 0000000..8ab471e --- /dev/null +++ b/fit_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_LISTENER_HPP) +#define FIT_MESG_LISTENER_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MesgListener +{ +public: + virtual ~MesgListener() {} + virtual void OnMesg(Mesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_LISTENER_HPP) diff --git a/fit_mesg_with_event.hpp b/fit_mesg_with_event.hpp new file mode 100644 index 0000000..b8b4bcb --- /dev/null +++ b/fit_mesg_with_event.hpp @@ -0,0 +1,38 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_WITH_EVENT_HPP) +#define FIT_MESG_WITH_EVENT_HPP + +#include "fit.hpp" +#include "fit_profile.hpp" + +namespace fit +{ + +class MesgWithEvent +{ +public: + virtual ~MesgWithEvent() {} + virtual FIT_DATE_TIME GetTimestamp(void) const = 0; + virtual void SetTimestamp(FIT_DATE_TIME timestamp) = 0; + virtual FIT_EVENT GetEvent() const = 0; + virtual void SetEvent(FIT_EVENT event) = 0; + virtual FIT_EVENT_TYPE GetEventType() const = 0; + virtual void SetEventType(FIT_EVENT_TYPE type) = 0; + virtual FIT_UINT8 GetEventGroup() const = 0; + virtual void SetEventGroup(FIT_UINT8 group) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_WITH_EVENT_HPP) diff --git a/fit_mesg_with_event_broadcaster.cpp b/fit_mesg_with_event_broadcaster.cpp new file mode 100644 index 0000000..1b76d4a --- /dev/null +++ b/fit_mesg_with_event_broadcaster.cpp @@ -0,0 +1,157 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_mesg_with_event_broadcaster.hpp" +#include + +namespace fit +{ + +#define MAX_GROUPS 256 +#define DEFAULT_GROUP 255 +#define BEGIN_END_GROUP 254 + +MesgWithEventBroadcaster::MesgWithEventBroadcaster(void) +{ + for (int i = 0; i < MAX_GROUPS; i++) { + startedEvents.push_back(std::list()); + } +} + +void MesgWithEventBroadcaster::AddListener(MesgWithEventListener& mesgObserver) +{ + listeners.push_back(&mesgObserver); +} + +void MesgWithEventBroadcaster::RemoveListener(MesgWithEventListener& mesgObserver) +{ + std::vector::iterator it = std::find(listeners.begin(), listeners.end(), &mesgObserver); + if (listeners.end() != it) + listeners.erase(it); +} + +void MesgWithEventBroadcaster::OnMesg(MesgWithEvent& mesg) +{ + (void)mesg; + /* + MesgWithEvent broadcastMesg(mesg); + int group = DEFAULT_GROUP; + + if (broadcastMesg.GetEventGroup() != UINT8_INVALID) + { + group = broadcastMesg.GetEventGroup(); + } + + if (broadcastMesg.GetEventType() == EVENT_TYPE_INVALID) + return; // Invalid so ignore. + + // Convert depreciated events types for backwards compatibility. + switch (broadcastMesg.GetEventType()) + { + case EVENT_TYPE_BEGIN_DEPRECIATED: + group = BEGIN_END_GROUP; + broadcastMesg.SetEventType(EVENT_TYPE_START); + break; + + case EVENT_TYPE_END_DEPRECIATED: + group = BEGIN_END_GROUP; + broadcastMesg.SetEventType(EVENT_TYPE_STOP); + break; + + case EVENT_TYPE_CONSECUTIVE_DEPRECIATED: + broadcastMesg.SetEventType(EVENT_TYPE_STOP); + break; + + case EVENT_TYPE_END_ALL_DEPRECIATED: + group = BEGIN_END_GROUP; + broadcastMesg.SetEventType(EVENT_TYPE_STOP_ALL); + break; + + default: + break; + } + + switch (broadcastMesg.GetEventType()) + { + case EVENT_TYPE_START: + for (list::iterator it = startedEvents.begin(); it < startedEvents[group].end(); it++) + { + if (startedEvents[group][i].GetEvent() == broadcastMesg.GetEvent()) + { + MesgWithEvent stopEvent(startedEvents[group].[i]); + stopEvent.SetEventType(EVENT_TYPE_STOP); + stopEvent.SetTimestamp(broadcastMesg.GetTimestamp()); + Broadcast(stopEvent); + startedEvents[group].remove(stopEvent); + } + } + + startedEvents[group].add(broadcastMesg); + break; + + case EVENT_TYPE_STOP: + case EVENT_TYPE_STOP_DISABLE: + for (int i = 0; i < startedEvents.get(group).size(); i++) { + if (startedEvents.get(group).get(i).getEvent() == broadcastMesg.getEvent()) { + startedEvents.get(group).remove(i); + } + } + break; + + case EVENT_TYPE_STOP_ALL: + for (int i = 0; i < (int)startedEvents[group].size(); i++) { + if (startedEvents.get(group).get(i).getEvent() != broadcastMesg.getEvent()) { + MesgWithEvent stopEvent = (MesgWithEvent)Factory.createMesg((Mesg)startedEvents.get(group).get(i)); + stopEvent.setEventType(EventType.STOP); + stopEvent.setTimestamp(broadcastMesg.getTimestamp()); + broadcast(stopEvent); + } + } + + startedEvents.get(group).clear(); + broadcastMesg.setEventType(EventType.STOP); + break; + + case EVENT_TYPE_STOP_DISABLE_ALL: + for (int i = 0; i < startedEvents.get(group).size(); i++) { + if (startedEvents.get(group).get(i).getEvent() != broadcastMesg.getEvent()) { + MesgWithEvent stopEvent = (MesgWithEvent)Factory.createMesg((Mesg)startedEvents.get(group).get(i)); + stopEvent.setEventType(EVENT_TYPE_STOP_DISABLE); + stopEvent.setTimestamp(broadcastMesg.getTimestamp()); + broadcast(stopEvent); + } + } + + startedEvents.get(group).clear(); + broadcastMesg.SetEventType(EVENT_TYPE_STOP_DISABLE); + break; + + case EVENT_TYPE_MARKER: + default: + break; + } + + Broadcast(broadcastMesg); + + */ +} + +void MesgWithEventBroadcaster::Broadcast(MesgWithEvent& mesg) +{ + for (int i = 0; i < (int)listeners.size(); i++) + { + listeners[i]->OnMesg(mesg); + } +} + + +} // namespace fit diff --git a/fit_mesg_with_event_broadcaster.hpp b/fit_mesg_with_event_broadcaster.hpp new file mode 100644 index 0000000..b0fa63b --- /dev/null +++ b/fit_mesg_with_event_broadcaster.hpp @@ -0,0 +1,41 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_WITH_EVENT_BROADCASTER_HPP) +#define FIT_MESG_WITH_EVENT_BROADCASTER_HPP + +#include +#include +#include "fit_mesg_with_event_listener.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class MesgWithEventBroadcaster : public MesgWithEventListener +{ +public: + MesgWithEventBroadcaster(void); + void AddListener(MesgWithEventListener& mesgObserver); + void RemoveListener(MesgWithEventListener& mesgObserver); + void OnMesg(MesgWithEvent& mesg); + +private: + void Broadcast(MesgWithEvent& mesg); + + std::vector listeners; + std::vector > startedEvents; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_WITH_EVENT_BROADCASTER_HPP) diff --git a/fit_mesg_with_event_listener.hpp b/fit_mesg_with_event_listener.hpp new file mode 100644 index 0000000..9c8c7f1 --- /dev/null +++ b/fit_mesg_with_event_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MESG_WITH_EVENT_LISTENER_HPP) +#define FIT_MESG_WITH_EVENT_LISTENER_HPP + +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class MesgWithEventListener +{ +public: + virtual ~MesgWithEventListener() {} + virtual void OnMesg(MesgWithEvent& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MESG_WITH_EVENT_LISTENER_HPP) diff --git a/fit_met_zone_mesg.hpp b/fit_met_zone_mesg.hpp new file mode 100644 index 0000000..1499a9c --- /dev/null +++ b/fit_met_zone_mesg.hpp @@ -0,0 +1,174 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MET_ZONE_MESG_HPP) +#define FIT_MET_ZONE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MetZoneMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 HighBpm = 1; + static const FIT_UINT8 Calories = 2; + static const FIT_UINT8 FatCalories = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MetZoneMesg(void) : Mesg(Profile::MESG_MET_ZONE) + { + } + + MetZoneMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of high_bpm field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHighBpmValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns high_bpm field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHighBpm(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set high_bpm field + /////////////////////////////////////////////////////////////////////// + void SetHighBpm(FIT_UINT8 highBpm) + { + SetFieldUINT8Value(1, highBpm, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCaloriesValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calories field + // Units: kcal / min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCalories(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calories field + // Units: kcal / min + /////////////////////////////////////////////////////////////////////// + void SetCalories(FIT_FLOAT32 calories) + { + SetFieldFLOAT32Value(2, calories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fat_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFatCaloriesValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fat_calories field + // Units: kcal / min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFatCalories(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fat_calories field + // Units: kcal / min + /////////////////////////////////////////////////////////////////////// + void SetFatCalories(FIT_FLOAT32 fatCalories) + { + SetFieldFLOAT32Value(3, fatCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MET_ZONE_MESG_HPP) diff --git a/fit_met_zone_mesg_listener.hpp b/fit_met_zone_mesg_listener.hpp new file mode 100644 index 0000000..7894b07 --- /dev/null +++ b/fit_met_zone_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MET_ZONE_MESG_LISTENER_HPP) +#define FIT_MET_ZONE_MESG_LISTENER_HPP + +#include "fit_met_zone_mesg.hpp" + +namespace fit +{ + +class MetZoneMesgListener +{ +public: + virtual ~MetZoneMesgListener() {} + virtual void OnMesg(MetZoneMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MET_ZONE_MESG_LISTENER_HPP) diff --git a/fit_monitoring_hr_data_mesg.hpp b/fit_monitoring_hr_data_mesg.hpp new file mode 100644 index 0000000..0dd4dcb --- /dev/null +++ b/fit_monitoring_hr_data_mesg.hpp @@ -0,0 +1,150 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MONITORING_HR_DATA_MESG_HPP) +#define FIT_MONITORING_HR_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MonitoringHrDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 RestingHeartRate = 0; + static const FIT_UINT8 CurrentDayRestingHeartRate = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MonitoringHrDataMesg(void) : Mesg(Profile::MESG_MONITORING_HR_DATA) + { + } + + MonitoringHrDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Must align to logging interval, for example, time must be 00:00:00 for daily log. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Must align to logging interval, for example, time must be 00:00:00 for daily log. + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of resting_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRestingHeartRateValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns resting_heart_rate field + // Units: bpm + // Comment: 7-day rolling average + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRestingHeartRate(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set resting_heart_rate field + // Units: bpm + // Comment: 7-day rolling average + /////////////////////////////////////////////////////////////////////// + void SetRestingHeartRate(FIT_UINT8 restingHeartRate) + { + SetFieldUINT8Value(0, restingHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of current_day_resting_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCurrentDayRestingHeartRateValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns current_day_resting_heart_rate field + // Units: bpm + // Comment: RHR for today only. (Feeds into 7-day average) + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetCurrentDayRestingHeartRate(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set current_day_resting_heart_rate field + // Units: bpm + // Comment: RHR for today only. (Feeds into 7-day average) + /////////////////////////////////////////////////////////////////////// + void SetCurrentDayRestingHeartRate(FIT_UINT8 currentDayRestingHeartRate) + { + SetFieldUINT8Value(1, currentDayRestingHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MONITORING_HR_DATA_MESG_HPP) diff --git a/fit_monitoring_hr_data_mesg_listener.hpp b/fit_monitoring_hr_data_mesg_listener.hpp new file mode 100644 index 0000000..e1ce9e7 --- /dev/null +++ b/fit_monitoring_hr_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MONITORING_HR_DATA_MESG_LISTENER_HPP) +#define FIT_MONITORING_HR_DATA_MESG_LISTENER_HPP + +#include "fit_monitoring_hr_data_mesg.hpp" + +namespace fit +{ + +class MonitoringHrDataMesgListener +{ +public: + virtual ~MonitoringHrDataMesgListener() {} + virtual void OnMesg(MonitoringHrDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MONITORING_HR_DATA_MESG_LISTENER_HPP) diff --git a/fit_monitoring_info_mesg.hpp b/fit_monitoring_info_mesg.hpp new file mode 100644 index 0000000..61cb814 --- /dev/null +++ b/fit_monitoring_info_mesg.hpp @@ -0,0 +1,274 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MONITORING_INFO_MESG_HPP) +#define FIT_MONITORING_INFO_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MonitoringInfoMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 LocalTimestamp = 0; + static const FIT_UINT8 ActivityType = 1; + static const FIT_UINT8 CyclesToDistance = 3; + static const FIT_UINT8 CyclesToCalories = 4; + static const FIT_UINT8 RestingMetabolicRate = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MonitoringInfoMesg(void) : Mesg(Profile::MESG_MONITORING_INFO) + { + } + + MonitoringInfoMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalTimestampValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns local_timestamp field + // Units: s + // Comment: Use to convert activity timestamps to local time if device does not support time zone and daylight savings time correction. + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DATE_TIME GetLocalTimestamp(void) const + { + return GetFieldUINT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_timestamp field + // Units: s + // Comment: Use to convert activity timestamps to local time if device does not support time zone and daylight savings time correction. + /////////////////////////////////////////////////////////////////////// + void SetLocalTimestamp(FIT_LOCAL_DATE_TIME localTimestamp) + { + SetFieldUINT32Value(0, localTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of activity_type + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumActivityType(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityTypeValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_type field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_TYPE GetActivityType(FIT_UINT8 index) const + { + return GetFieldENUMValue(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_type field + /////////////////////////////////////////////////////////////////////// + void SetActivityType(FIT_UINT8 index, FIT_ACTIVITY_TYPE activityType) + { + SetFieldENUMValue(1, activityType, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of cycles_to_distance + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCyclesToDistance(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycles_to_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCyclesToDistanceValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycles_to_distance field + // Units: m/cycle + // Comment: Indexed by activity_type + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCyclesToDistance(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycles_to_distance field + // Units: m/cycle + // Comment: Indexed by activity_type + /////////////////////////////////////////////////////////////////////// + void SetCyclesToDistance(FIT_UINT8 index, FIT_FLOAT32 cyclesToDistance) + { + SetFieldFLOAT32Value(3, cyclesToDistance, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of cycles_to_calories + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCyclesToCalories(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycles_to_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCyclesToCaloriesValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycles_to_calories field + // Units: kcal/cycle + // Comment: Indexed by activity_type + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCyclesToCalories(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycles_to_calories field + // Units: kcal/cycle + // Comment: Indexed by activity_type + /////////////////////////////////////////////////////////////////////// + void SetCyclesToCalories(FIT_UINT8 index, FIT_FLOAT32 cyclesToCalories) + { + SetFieldFLOAT32Value(4, cyclesToCalories, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of resting_metabolic_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRestingMetabolicRateValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns resting_metabolic_rate field + // Units: kcal / day + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRestingMetabolicRate(void) const + { + return GetFieldUINT16Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set resting_metabolic_rate field + // Units: kcal / day + /////////////////////////////////////////////////////////////////////// + void SetRestingMetabolicRate(FIT_UINT16 restingMetabolicRate) + { + SetFieldUINT16Value(5, restingMetabolicRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MONITORING_INFO_MESG_HPP) diff --git a/fit_monitoring_info_mesg_listener.hpp b/fit_monitoring_info_mesg_listener.hpp new file mode 100644 index 0000000..2ef2403 --- /dev/null +++ b/fit_monitoring_info_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MONITORING_INFO_MESG_LISTENER_HPP) +#define FIT_MONITORING_INFO_MESG_LISTENER_HPP + +#include "fit_monitoring_info_mesg.hpp" + +namespace fit +{ + +class MonitoringInfoMesgListener +{ +public: + virtual ~MonitoringInfoMesgListener() {} + virtual void OnMesg(MonitoringInfoMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MONITORING_INFO_MESG_LISTENER_HPP) diff --git a/fit_monitoring_mesg.hpp b/fit_monitoring_mesg.hpp new file mode 100644 index 0000000..773e736 --- /dev/null +++ b/fit_monitoring_mesg.hpp @@ -0,0 +1,1122 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MONITORING_MESG_HPP) +#define FIT_MONITORING_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class MonitoringMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 DeviceIndex = 0; + static const FIT_UINT8 Calories = 1; + static const FIT_UINT8 Distance = 2; + static const FIT_UINT8 Cycles = 3; + static const FIT_UINT8 ActiveTime = 4; + static const FIT_UINT8 ActivityType = 5; + static const FIT_UINT8 ActivitySubtype = 6; + static const FIT_UINT8 ActivityLevel = 7; + static const FIT_UINT8 Distance16 = 8; + static const FIT_UINT8 Cycles16 = 9; + static const FIT_UINT8 ActiveTime16 = 10; + static const FIT_UINT8 LocalTimestamp = 11; + static const FIT_UINT8 Temperature = 12; + static const FIT_UINT8 TemperatureMin = 14; + static const FIT_UINT8 TemperatureMax = 15; + static const FIT_UINT8 ActivityTime = 16; + static const FIT_UINT8 ActiveCalories = 19; + static const FIT_UINT8 CurrentActivityTypeIntensity = 24; + static const FIT_UINT8 TimestampMin8 = 25; + static const FIT_UINT8 Timestamp16 = 26; + static const FIT_UINT8 HeartRate = 27; + static const FIT_UINT8 Intensity = 28; + static const FIT_UINT8 DurationMin = 29; + static const FIT_UINT8 Duration = 30; + static const FIT_UINT8 Ascent = 31; + static const FIT_UINT8 Descent = 32; + static const FIT_UINT8 ModerateActivityMinutes = 33; + static const FIT_UINT8 VigorousActivityMinutes = 34; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + MonitoringMesg(void) : Mesg(Profile::MESG_MONITORING) + { + } + + MonitoringMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Must align to logging interval, for example, time must be 00:00:00 for daily log. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Must align to logging interval, for example, time must be 00:00:00 for daily log. + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIndexValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_index field + // Comment: Associates this data to device_info message. Not required for file with single device (sensor). + /////////////////////////////////////////////////////////////////////// + FIT_DEVICE_INDEX GetDeviceIndex(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_index field + // Comment: Associates this data to device_info message. Not required for file with single device (sensor). + /////////////////////////////////////////////////////////////////////// + void SetDeviceIndex(FIT_DEVICE_INDEX deviceIndex) + { + SetFieldUINT8Value(0, deviceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCaloriesValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calories field + // Units: kcal + // Comment: Accumulated total calories. Maintained by MonitoringReader for each activity_type. See SDK documentation + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCalories(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calories field + // Units: kcal + // Comment: Accumulated total calories. Maintained by MonitoringReader for each activity_type. See SDK documentation + /////////////////////////////////////////////////////////////////////// + void SetCalories(FIT_UINT16 calories) + { + SetFieldUINT16Value(1, calories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance field + // Units: m + // Comment: Accumulated distance. Maintained by MonitoringReader for each activity_type. See SDK documentation. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDistance(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance field + // Units: m + // Comment: Accumulated distance. Maintained by MonitoringReader for each activity_type. See SDK documentation. + /////////////////////////////////////////////////////////////////////// + void SetDistance(FIT_FLOAT32 distance) + { + SetFieldFLOAT32Value(2, distance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCyclesValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycles field + // Units: cycles + // Comment: Accumulated cycles. Maintained by MonitoringReader for each activity_type. See SDK documentation. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCycles(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycles field + // Units: cycles + // Comment: Accumulated cycles. Maintained by MonitoringReader for each activity_type. See SDK documentation. + /////////////////////////////////////////////////////////////////////// + void SetCycles(FIT_FLOAT32 cycles) + { + SetFieldFLOAT32Value(3, cycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of steps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStepsValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STEPS ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STEPS); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns steps field + // Units: steps + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSteps(void) const + { + return GetFieldUINT32Value(3, 0, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STEPS); + } + + /////////////////////////////////////////////////////////////////////// + // Set steps field + // Units: steps + /////////////////////////////////////////////////////////////////////// + void SetSteps(FIT_UINT32 steps) + { + SetFieldUINT32Value(3, steps, 0, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STEPS); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of strokes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStrokesValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STROKES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STROKES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStrokes(void) const + { + return GetFieldFLOAT32Value(3, 0, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Set strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + void SetStrokes(FIT_FLOAT32 strokes) + { + SetFieldFLOAT32Value(3, strokes, 0, (FIT_UINT16) Profile::MONITORING_MESG_CYCLES_FIELD_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveTimeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetActiveTime(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetActiveTime(FIT_FLOAT32 activeTime) + { + SetFieldFLOAT32Value(4, activeTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityTypeValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_type field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_TYPE GetActivityType(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_type field + /////////////////////////////////////////////////////////////////////// + void SetActivityType(FIT_ACTIVITY_TYPE activityType) + { + SetFieldENUMValue(5, activityType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_subtype field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivitySubtypeValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_subtype field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_SUBTYPE GetActivitySubtype(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_subtype field + /////////////////////////////////////////////////////////////////////// + void SetActivitySubtype(FIT_ACTIVITY_SUBTYPE activitySubtype) + { + SetFieldENUMValue(6, activitySubtype, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityLevelValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_level field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_LEVEL GetActivityLevel(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_level field + /////////////////////////////////////////////////////////////////////// + void SetActivityLevel(FIT_ACTIVITY_LEVEL activityLevel) + { + SetFieldENUMValue(7, activityLevel, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance_16 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistance16Valid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance_16 field + // Units: 100 * m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetDistance16(void) const + { + return GetFieldUINT16Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance_16 field + // Units: 100 * m + /////////////////////////////////////////////////////////////////////// + void SetDistance16(FIT_UINT16 distance16) + { + SetFieldUINT16Value(8, distance16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycles_16 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCycles16Valid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycles_16 field + // Units: 2 * cycles (steps) + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCycles16(void) const + { + return GetFieldUINT16Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycles_16 field + // Units: 2 * cycles (steps) + /////////////////////////////////////////////////////////////////////// + void SetCycles16(FIT_UINT16 cycles16) + { + SetFieldUINT16Value(9, cycles16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_time_16 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveTime16Valid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_time_16 field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetActiveTime16(void) const + { + return GetFieldUINT16Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_time_16 field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetActiveTime16(FIT_UINT16 activeTime16) + { + SetFieldUINT16Value(10, activeTime16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalTimestampValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns local_timestamp field + // Comment: Must align to logging interval, for example, time must be 00:00:00 for daily log. + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DATE_TIME GetLocalTimestamp(void) const + { + return GetFieldUINT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_timestamp field + // Comment: Must align to logging interval, for example, time must be 00:00:00 for daily log. + /////////////////////////////////////////////////////////////////////// + void SetLocalTimestamp(FIT_LOCAL_DATE_TIME localTimestamp) + { + SetFieldUINT32Value(11, localTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature field + // Units: C + // Comment: Avg temperature during the logging interval ended at timestamp + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTemperature(void) const + { + return GetFieldFLOAT32Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature field + // Units: C + // Comment: Avg temperature during the logging interval ended at timestamp + /////////////////////////////////////////////////////////////////////// + void SetTemperature(FIT_FLOAT32 temperature) + { + SetFieldFLOAT32Value(12, temperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature_min field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureMinValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature_min field + // Units: C + // Comment: Min temperature during the logging interval ended at timestamp + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTemperatureMin(void) const + { + return GetFieldFLOAT32Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature_min field + // Units: C + // Comment: Min temperature during the logging interval ended at timestamp + /////////////////////////////////////////////////////////////////////// + void SetTemperatureMin(FIT_FLOAT32 temperatureMin) + { + SetFieldFLOAT32Value(14, temperatureMin, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature_max field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureMaxValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature_max field + // Units: C + // Comment: Max temperature during the logging interval ended at timestamp + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTemperatureMax(void) const + { + return GetFieldFLOAT32Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature_max field + // Units: C + // Comment: Max temperature during the logging interval ended at timestamp + /////////////////////////////////////////////////////////////////////// + void SetTemperatureMax(FIT_FLOAT32 temperatureMax) + { + SetFieldFLOAT32Value(15, temperatureMax, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of activity_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumActivityTime(void) const + { + return GetFieldNumValues(16, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_time field + // Units: minutes + // Comment: Indexed using minute_activity_level enum + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetActivityTime(FIT_UINT8 index) const + { + return GetFieldUINT16Value(16, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_time field + // Units: minutes + // Comment: Indexed using minute_activity_level enum + /////////////////////////////////////////////////////////////////////// + void SetActivityTime(FIT_UINT8 index, FIT_UINT16 activityTime) + { + SetFieldUINT16Value(16, activityTime, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveCaloriesValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetActiveCalories(void) const + { + return GetFieldUINT16Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetActiveCalories(FIT_UINT16 activeCalories) + { + SetFieldUINT16Value(19, activeCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of current_activity_type_intensity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCurrentActivityTypeIntensityValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns current_activity_type_intensity field + // Comment: Indicates single type / intensity for duration since last monitoring message. + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetCurrentActivityTypeIntensity(void) const + { + return GetFieldBYTEValue(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set current_activity_type_intensity field + // Comment: Indicates single type / intensity for duration since last monitoring message. + /////////////////////////////////////////////////////////////////////// + void SetCurrentActivityTypeIntensity(FIT_BYTE currentActivityTypeIntensity) + { + SetFieldBYTEValue(24, currentActivityTypeIntensity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_min_8 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMin8Valid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_min_8 field + // Units: min + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetTimestampMin8(void) const + { + return GetFieldUINT8Value(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_min_8 field + // Units: min + /////////////////////////////////////////////////////////////////////// + void SetTimestampMin8(FIT_UINT8 timestampMin8) + { + SetFieldUINT8Value(25, timestampMin8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_16 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestamp16Valid() const + { + const Field* field = GetField(26); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_16 field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestamp16(void) const + { + return GetFieldUINT16Value(26, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_16 field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp16(FIT_UINT16 timestamp16) + { + SetFieldUINT16Value(26, timestamp16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateValid() const + { + const Field* field = GetField(27); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHeartRate(void) const + { + return GetFieldUINT8Value(27, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHeartRate(FIT_UINT8 heartRate) + { + SetFieldUINT8Value(27, heartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of intensity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIntensityValid() const + { + const Field* field = GetField(28); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns intensity field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetIntensity(void) const + { + return GetFieldFLOAT32Value(28, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set intensity field + /////////////////////////////////////////////////////////////////////// + void SetIntensity(FIT_FLOAT32 intensity) + { + SetFieldFLOAT32Value(28, intensity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_min field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationMinValid() const + { + const Field* field = GetField(29); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns duration_min field + // Units: min + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetDurationMin(void) const + { + return GetFieldUINT16Value(29, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_min field + // Units: min + /////////////////////////////////////////////////////////////////////// + void SetDurationMin(FIT_UINT16 durationMin) + { + SetFieldUINT16Value(29, durationMin, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationValid() const + { + const Field* field = GetField(30); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns duration field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDuration(void) const + { + return GetFieldUINT32Value(30, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetDuration(FIT_UINT32 duration) + { + SetFieldUINT32Value(30, duration, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAscentValid() const + { + const Field* field = GetField(31); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAscent(void) const + { + return GetFieldFLOAT32Value(31, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAscent(FIT_FLOAT32 ascent) + { + SetFieldFLOAT32Value(31, ascent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDescentValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDescent(void) const + { + return GetFieldFLOAT32Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDescent(FIT_FLOAT32 descent) + { + SetFieldFLOAT32Value(32, descent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of moderate_activity_minutes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsModerateActivityMinutesValid() const + { + const Field* field = GetField(33); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns moderate_activity_minutes field + // Units: minutes + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetModerateActivityMinutes(void) const + { + return GetFieldUINT16Value(33, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set moderate_activity_minutes field + // Units: minutes + /////////////////////////////////////////////////////////////////////// + void SetModerateActivityMinutes(FIT_UINT16 moderateActivityMinutes) + { + SetFieldUINT16Value(33, moderateActivityMinutes, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of vigorous_activity_minutes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVigorousActivityMinutesValid() const + { + const Field* field = GetField(34); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns vigorous_activity_minutes field + // Units: minutes + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetVigorousActivityMinutes(void) const + { + return GetFieldUINT16Value(34, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set vigorous_activity_minutes field + // Units: minutes + /////////////////////////////////////////////////////////////////////// + void SetVigorousActivityMinutes(FIT_UINT16 vigorousActivityMinutes) + { + SetFieldUINT16Value(34, vigorousActivityMinutes, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_MONITORING_MESG_HPP) diff --git a/fit_monitoring_mesg_listener.hpp b/fit_monitoring_mesg_listener.hpp new file mode 100644 index 0000000..40e682b --- /dev/null +++ b/fit_monitoring_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_MONITORING_MESG_LISTENER_HPP) +#define FIT_MONITORING_MESG_LISTENER_HPP + +#include "fit_monitoring_mesg.hpp" + +namespace fit +{ + +class MonitoringMesgListener +{ +public: + virtual ~MonitoringMesgListener() {} + virtual void OnMesg(MonitoringMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_MONITORING_MESG_LISTENER_HPP) diff --git a/fit_nmea_sentence_mesg.hpp b/fit_nmea_sentence_mesg.hpp new file mode 100644 index 0000000..304d6d7 --- /dev/null +++ b/fit_nmea_sentence_mesg.hpp @@ -0,0 +1,148 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_NMEA_SENTENCE_MESG_HPP) +#define FIT_NMEA_SENTENCE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class NmeaSentenceMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 Sentence = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + NmeaSentenceMesg(void) : Mesg(Profile::MESG_NMEA_SENTENCE) + { + } + + NmeaSentenceMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Timestamp message was output + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Timestamp message was output + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Fractional part of timestamp, added to timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Fractional part of timestamp, added to timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sentence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSentenceValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sentence field + // Comment: NMEA sentence + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetSentence(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sentence field + // Comment: NMEA sentence + /////////////////////////////////////////////////////////////////////// + void SetSentence(FIT_WSTRING sentence) + { + SetFieldSTRINGValue(1, sentence, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_NMEA_SENTENCE_MESG_HPP) diff --git a/fit_nmea_sentence_mesg_listener.hpp b/fit_nmea_sentence_mesg_listener.hpp new file mode 100644 index 0000000..494123e --- /dev/null +++ b/fit_nmea_sentence_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_NMEA_SENTENCE_MESG_LISTENER_HPP) +#define FIT_NMEA_SENTENCE_MESG_LISTENER_HPP + +#include "fit_nmea_sentence_mesg.hpp" + +namespace fit +{ + +class NmeaSentenceMesgListener +{ +public: + virtual ~NmeaSentenceMesgListener() {} + virtual void OnMesg(NmeaSentenceMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_NMEA_SENTENCE_MESG_LISTENER_HPP) diff --git a/fit_obdii_data_mesg.hpp b/fit_obdii_data_mesg.hpp new file mode 100644 index 0000000..a0f989c --- /dev/null +++ b/fit_obdii_data_mesg.hpp @@ -0,0 +1,388 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_OBDII_DATA_MESG_HPP) +#define FIT_OBDII_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ObdiiDataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 TimeOffset = 1; + static const FIT_UINT8 Pid = 2; + static const FIT_UINT8 RawData = 3; + static const FIT_UINT8 PidDataSize = 4; + static const FIT_UINT8 SystemTime = 5; + static const FIT_UINT8 StartTimestamp = 6; + static const FIT_UINT8 StartTimestampMs = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ObdiiDataMesg(void) : Mesg(Profile::MESG_OBDII_DATA) + { + } + + ObdiiDataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Timestamp message was output + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Timestamp message was output + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Fractional part of timestamp, added to timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Fractional part of timestamp, added to timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_offset + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeOffset(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_offset field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeOffsetValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_offset field + // Units: ms + // Comment: Offset of PID reading [i] from start_timestamp+start_timestamp_ms. Readings may span accross seconds. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimeOffset(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_offset field + // Units: ms + // Comment: Offset of PID reading [i] from start_timestamp+start_timestamp_ms. Readings may span accross seconds. + /////////////////////////////////////////////////////////////////////// + void SetTimeOffset(FIT_UINT8 index, FIT_UINT16 timeOffset) + { + SetFieldUINT16Value(1, timeOffset, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pid field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPidValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pid field + // Comment: Parameter ID + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetPid(void) const + { + return GetFieldBYTEValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pid field + // Comment: Parameter ID + /////////////////////////////////////////////////////////////////////// + void SetPid(FIT_BYTE pid) + { + SetFieldBYTEValue(2, pid, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of raw_data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumRawData(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of raw_data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRawDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns raw_data field + // Comment: Raw parameter data + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetRawData(FIT_UINT8 index) const + { + return GetFieldBYTEValue(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set raw_data field + // Comment: Raw parameter data + /////////////////////////////////////////////////////////////////////// + void SetRawData(FIT_UINT8 index, FIT_BYTE rawData) + { + SetFieldBYTEValue(3, rawData, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of pid_data_size + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumPidDataSize(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pid_data_size field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPidDataSizeValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pid_data_size field + // Comment: Optional, data size of PID[i]. If not specified refer to SAE J1979. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetPidDataSize(FIT_UINT8 index) const + { + return GetFieldUINT8Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pid_data_size field + // Comment: Optional, data size of PID[i]. If not specified refer to SAE J1979. + /////////////////////////////////////////////////////////////////////// + void SetPidDataSize(FIT_UINT8 index, FIT_UINT8 pidDataSize) + { + SetFieldUINT8Value(4, pidDataSize, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of system_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSystemTime(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of system_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSystemTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns system_time field + // Comment: System time associated with sample expressed in ms, can be used instead of time_offset. There will be a system_time value for each raw_data element. For multibyte pids the system_time is repeated. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSystemTime(FIT_UINT8 index) const + { + return GetFieldUINT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set system_time field + // Comment: System time associated with sample expressed in ms, can be used instead of time_offset. There will be a system_time value for each raw_data element. For multibyte pids the system_time is repeated. + /////////////////////////////////////////////////////////////////////// + void SetSystemTime(FIT_UINT8 index, FIT_UINT32 systemTime) + { + SetFieldUINT32Value(5, systemTime, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimestampValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_timestamp field + // Comment: Timestamp of first sample recorded in the message. Used with time_offset to generate time of each sample + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTimestamp(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_timestamp field + // Comment: Timestamp of first sample recorded in the message. Used with time_offset to generate time of each sample + /////////////////////////////////////////////////////////////////////// + void SetStartTimestamp(FIT_DATE_TIME startTimestamp) + { + SetFieldUINT32Value(6, startTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimestampMsValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_timestamp_ms field + // Units: ms + // Comment: Fractional part of start_timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStartTimestampMs(void) const + { + return GetFieldUINT16Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_timestamp_ms field + // Units: ms + // Comment: Fractional part of start_timestamp + /////////////////////////////////////////////////////////////////////// + void SetStartTimestampMs(FIT_UINT16 startTimestampMs) + { + SetFieldUINT16Value(7, startTimestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_OBDII_DATA_MESG_HPP) diff --git a/fit_obdii_data_mesg_listener.hpp b/fit_obdii_data_mesg_listener.hpp new file mode 100644 index 0000000..83efbf7 --- /dev/null +++ b/fit_obdii_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_OBDII_DATA_MESG_LISTENER_HPP) +#define FIT_OBDII_DATA_MESG_LISTENER_HPP + +#include "fit_obdii_data_mesg.hpp" + +namespace fit +{ + +class ObdiiDataMesgListener +{ +public: + virtual ~ObdiiDataMesgListener() {} + virtual void OnMesg(ObdiiDataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_OBDII_DATA_MESG_LISTENER_HPP) diff --git a/fit_ohr_settings_mesg.hpp b/fit_ohr_settings_mesg.hpp new file mode 100644 index 0000000..f5d0f3c --- /dev/null +++ b/fit_ohr_settings_mesg.hpp @@ -0,0 +1,108 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_OHR_SETTINGS_MESG_HPP) +#define FIT_OHR_SETTINGS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class OhrSettingsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Enabled = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + OhrSettingsMesg(void) : Mesg(Profile::MESG_OHR_SETTINGS) + { + } + + OhrSettingsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + /////////////////////////////////////////////////////////////////////// + FIT_SWITCH GetEnabled(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_SWITCH enabled) + { + SetFieldENUMValue(0, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_OHR_SETTINGS_MESG_HPP) diff --git a/fit_ohr_settings_mesg_listener.hpp b/fit_ohr_settings_mesg_listener.hpp new file mode 100644 index 0000000..943e095 --- /dev/null +++ b/fit_ohr_settings_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_OHR_SETTINGS_MESG_LISTENER_HPP) +#define FIT_OHR_SETTINGS_MESG_LISTENER_HPP + +#include "fit_ohr_settings_mesg.hpp" + +namespace fit +{ + +class OhrSettingsMesgListener +{ +public: + virtual ~OhrSettingsMesgListener() {} + virtual void OnMesg(OhrSettingsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_OHR_SETTINGS_MESG_LISTENER_HPP) diff --git a/fit_one_d_sensor_calibration_mesg.hpp b/fit_one_d_sensor_calibration_mesg.hpp new file mode 100644 index 0000000..3148981 --- /dev/null +++ b/fit_one_d_sensor_calibration_mesg.hpp @@ -0,0 +1,291 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ONE_D_SENSOR_CALIBRATION_MESG_HPP) +#define FIT_ONE_D_SENSOR_CALIBRATION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class OneDSensorCalibrationMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 SensorType = 0; + static const FIT_UINT8 CalibrationFactor = 1; + static const FIT_UINT8 CalibrationDivisor = 2; + static const FIT_UINT8 LevelShift = 3; + static const FIT_UINT8 OffsetCal = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + OneDSensorCalibrationMesg(void) : Mesg(Profile::MESG_ONE_D_SENSOR_CALIBRATION) + { + } + + OneDSensorCalibrationMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sensor_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSensorTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sensor_type field + // Comment: Indicates which sensor the calibration is for + /////////////////////////////////////////////////////////////////////// + FIT_SENSOR_TYPE GetSensorType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sensor_type field + // Comment: Indicates which sensor the calibration is for + /////////////////////////////////////////////////////////////////////// + void SetSensorType(FIT_SENSOR_TYPE sensorType) + { + SetFieldENUMValue(0, sensorType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibration_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibrationFactorValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibration_factor field + // Comment: Calibration factor used to convert from raw ADC value to degrees, g, etc. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCalibrationFactor(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibration_factor field + // Comment: Calibration factor used to convert from raw ADC value to degrees, g, etc. + /////////////////////////////////////////////////////////////////////// + void SetCalibrationFactor(FIT_UINT32 calibrationFactor) + { + SetFieldUINT32Value(1, calibrationFactor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of baro_cal_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBaroCalFactorValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_BARO_CAL_FACTOR ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_BARO_CAL_FACTOR); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns baro_cal_factor field + // Units: Pa + // Comment: Barometer calibration factor + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetBaroCalFactor(void) const + { + return GetFieldUINT32Value(1, 0, (FIT_UINT16) Profile::ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_BARO_CAL_FACTOR); + } + + /////////////////////////////////////////////////////////////////////// + // Set baro_cal_factor field + // Units: Pa + // Comment: Barometer calibration factor + /////////////////////////////////////////////////////////////////////// + void SetBaroCalFactor(FIT_UINT32 baroCalFactor) + { + SetFieldUINT32Value(1, baroCalFactor, 0, (FIT_UINT16) Profile::ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_BARO_CAL_FACTOR); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibration_divisor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibrationDivisorValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibration_divisor field + // Units: counts + // Comment: Calibration factor divisor + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCalibrationDivisor(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibration_divisor field + // Units: counts + // Comment: Calibration factor divisor + /////////////////////////////////////////////////////////////////////// + void SetCalibrationDivisor(FIT_UINT32 calibrationDivisor) + { + SetFieldUINT32Value(2, calibrationDivisor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of level_shift field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLevelShiftValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns level_shift field + // Comment: Level shift value used to shift the ADC value back into range + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetLevelShift(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set level_shift field + // Comment: Level shift value used to shift the ADC value back into range + /////////////////////////////////////////////////////////////////////// + void SetLevelShift(FIT_UINT32 levelShift) + { + SetFieldUINT32Value(3, levelShift, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of offset_cal field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOffsetCalValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns offset_cal field + // Comment: Internal Calibration factor + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetOffsetCal(void) const + { + return GetFieldSINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set offset_cal field + // Comment: Internal Calibration factor + /////////////////////////////////////////////////////////////////////// + void SetOffsetCal(FIT_SINT32 offsetCal) + { + SetFieldSINT32Value(4, offsetCal, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ONE_D_SENSOR_CALIBRATION_MESG_HPP) diff --git a/fit_one_d_sensor_calibration_mesg_listener.hpp b/fit_one_d_sensor_calibration_mesg_listener.hpp new file mode 100644 index 0000000..1bb5358 --- /dev/null +++ b/fit_one_d_sensor_calibration_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ONE_D_SENSOR_CALIBRATION_MESG_LISTENER_HPP) +#define FIT_ONE_D_SENSOR_CALIBRATION_MESG_LISTENER_HPP + +#include "fit_one_d_sensor_calibration_mesg.hpp" + +namespace fit +{ + +class OneDSensorCalibrationMesgListener +{ +public: + virtual ~OneDSensorCalibrationMesgListener() {} + virtual void OnMesg(OneDSensorCalibrationMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ONE_D_SENSOR_CALIBRATION_MESG_LISTENER_HPP) diff --git a/fit_pad_mesg.hpp b/fit_pad_mesg.hpp new file mode 100644 index 0000000..a7afb91 --- /dev/null +++ b/fit_pad_mesg.hpp @@ -0,0 +1,42 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_PAD_MESG_HPP) +#define FIT_PAD_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class PadMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + PadMesg(void) : Mesg(Profile::MESG_PAD) + { + } + + PadMesg(const Mesg &mesg) : Mesg(mesg) + { + } + +}; + +} // namespace fit + +#endif // !defined(FIT_PAD_MESG_HPP) diff --git a/fit_pad_mesg_listener.hpp b/fit_pad_mesg_listener.hpp new file mode 100644 index 0000000..d3d0efb --- /dev/null +++ b/fit_pad_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_PAD_MESG_LISTENER_HPP) +#define FIT_PAD_MESG_LISTENER_HPP + +#include "fit_pad_mesg.hpp" + +namespace fit +{ + +class PadMesgListener +{ +public: + virtual ~PadMesgListener() {} + virtual void OnMesg(PadMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_PAD_MESG_LISTENER_HPP) diff --git a/fit_power_zone_mesg.hpp b/fit_power_zone_mesg.hpp new file mode 100644 index 0000000..d519f6e --- /dev/null +++ b/fit_power_zone_mesg.hpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_POWER_ZONE_MESG_HPP) +#define FIT_POWER_ZONE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class PowerZoneMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 HighValue = 1; + static const FIT_UINT8 Name = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + PowerZoneMesg(void) : Mesg(Profile::MESG_POWER_ZONE) + { + } + + PowerZoneMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of high_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHighValueValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns high_value field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetHighValue(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set high_value field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetHighValue(FIT_UINT16 highValue) + { + SetFieldUINT16Value(1, highValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(2, name, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_POWER_ZONE_MESG_HPP) diff --git a/fit_power_zone_mesg_listener.hpp b/fit_power_zone_mesg_listener.hpp new file mode 100644 index 0000000..804d45c --- /dev/null +++ b/fit_power_zone_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_POWER_ZONE_MESG_LISTENER_HPP) +#define FIT_POWER_ZONE_MESG_LISTENER_HPP + +#include "fit_power_zone_mesg.hpp" + +namespace fit +{ + +class PowerZoneMesgListener +{ +public: + virtual ~PowerZoneMesgListener() {} + virtual void OnMesg(PowerZoneMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_POWER_ZONE_MESG_LISTENER_HPP) diff --git a/fit_profile.cpp b/fit_profile.cpp new file mode 100644 index 0000000..eaf4685 --- /dev/null +++ b/fit_profile.cpp @@ -0,0 +1,3187 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_profile.hpp" + +namespace fit +{ + +static const Profile::SUBFIELD_MAP fileIdProductFaveroProductMaps[] = +{ + { 263, 1 }, // manufacturer == favero_electronics +}; + +static const Profile::SUBFIELD_MAP fileIdProductGarminProductMaps[] = +{ + { 1, 1 }, // manufacturer == garmin + { 15, 1 }, // manufacturer == dynastream + { 13, 1 }, // manufacturer == dynastream_oem + { 89, 1 }, // manufacturer == tacx +}; + +static const Profile::SUBFIELD fileIdProductSubFields[] = +{ + { fileIdProductFaveroProductMaps, 0, "favero_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { fileIdProductGarminProductMaps, 0, "garmin_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 132 }, +}; + +static const Profile::FIELD fileIdFields[] = +{ +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::File }, +{ 0, 0, "manufacturer", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Manufacturer }, +{ 0, fileIdProductSubFields, "product", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "serial_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 140, false, Profile::Type::Uint32z }, +{ 0, 0, "time_created", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::DateTime }, +{ 0, 0, "number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "product_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD fileCreatorFields[] = +{ +{ 0, 0, "software_version", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "hardware_version", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD timestampCorrelationFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "fractional_timestamp", "s", (FIT_FLOAT64)32768, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "system_timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::DateTime }, +{ 0, 0, "fractional_system_timestamp", "s", (FIT_FLOAT64)32768, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "local_timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::LocalDateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "system_timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD softwareFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "version", "", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "part_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 7, false, Profile::Type::String }, +}; + +static const Profile::SUBFIELD_MAP slaveDeviceProductFaveroProductMaps[] = +{ + { 263, 0 }, // manufacturer == favero_electronics +}; + +static const Profile::SUBFIELD_MAP slaveDeviceProductGarminProductMaps[] = +{ + { 1, 0 }, // manufacturer == garmin + { 15, 0 }, // manufacturer == dynastream + { 13, 0 }, // manufacturer == dynastream_oem + { 89, 0 }, // manufacturer == tacx +}; + +static const Profile::SUBFIELD slaveDeviceProductSubFields[] = +{ + { slaveDeviceProductFaveroProductMaps, 0, "favero_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { slaveDeviceProductGarminProductMaps, 0, "garmin_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 132 }, +}; + +static const Profile::FIELD slaveDeviceFields[] = +{ +{ 0, 0, "manufacturer", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Manufacturer }, +{ 0, slaveDeviceProductSubFields, "product", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 1, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD capabilitiesFields[] = +{ +{ 0, 0, "languages", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "sports", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 10, false, Profile::Type::SportBits0 }, +{ 0, 0, "workouts_supported", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 140, false, Profile::Type::WorkoutCapabilities }, +{ 0, 0, "connectivity_supported", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 140, false, Profile::Type::ConnectivityCapabilities }, +}; + +static const Profile::FIELD fileCapabilitiesFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::File }, +{ 0, 0, "flags", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 10, false, Profile::Type::FileFlags }, +{ 0, 0, "directory", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 7, false, Profile::Type::String }, +{ 0, 0, "max_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_size", "bytes", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::SUBFIELD_MAP mesgCapabilitiesCountNumPerFileMaps[] = +{ + { 0, 2 }, // count_type == num_per_file +}; + +static const Profile::SUBFIELD_MAP mesgCapabilitiesCountMaxPerFileMaps[] = +{ + { 1, 2 }, // count_type == max_per_file +}; + +static const Profile::SUBFIELD_MAP mesgCapabilitiesCountMaxPerFileTypeMaps[] = +{ + { 2, 2 }, // count_type == max_per_file_type +}; + +static const Profile::SUBFIELD mesgCapabilitiesCountSubFields[] = +{ + { mesgCapabilitiesCountNumPerFileMaps, 0, "num_per_file", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { mesgCapabilitiesCountMaxPerFileMaps, 0, "max_per_file", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { mesgCapabilitiesCountMaxPerFileTypeMaps, 0, "max_per_file_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, +}; + +static const Profile::FIELD mesgCapabilitiesFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "file", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::File }, +{ 0, 0, "mesg_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::MesgNum }, +{ 0, 0, "count_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::MesgCount }, +{ 0, mesgCapabilitiesCountSubFields, "count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 3, 3, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD fieldCapabilitiesFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "file", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::File }, +{ 0, 0, "mesg_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::MesgNum }, +{ 0, 0, "field_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD deviceSettingsFields[] = +{ +{ 0, 0, "active_time_zone", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "utc_offset", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_offset", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::TimeMode }, +{ 0, 0, "time_zone_offset", "hr", (FIT_FLOAT64)4, (FIT_FLOAT64)0, 0, 0, 5, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "backlight_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::BacklightMode }, +{ 0, 0, "activity_tracker_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 36, 0, false, Profile::Type::Bool }, +{ 0, 0, "clock_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 39, 134, false, Profile::Type::DateTime }, +{ 0, 0, "pages_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 40, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "move_alert_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 46, 0, false, Profile::Type::Bool }, +{ 0, 0, "date_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 47, 0, false, Profile::Type::DateMode }, +{ 0, 0, "display_orientation", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 55, 0, false, Profile::Type::DisplayOrientation }, +{ 0, 0, "mounting_side", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 56, 0, false, Profile::Type::Side }, +{ 0, 0, "default_page", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 57, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "autosync_min_steps", "steps", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 58, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "autosync_min_time", "minutes", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 59, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "lactate_threshold_autodetect_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 80, 0, false, Profile::Type::Bool }, +{ 0, 0, "ble_auto_upload_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 86, 0, false, Profile::Type::Bool }, +{ 0, 0, "auto_sync_frequency", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 89, 0, false, Profile::Type::AutoSyncFrequency }, +{ 0, 0, "auto_activity_detect", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 90, 134, false, Profile::Type::AutoActivityDetect }, +{ 0, 0, "number_of_screens", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 94, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "smart_notification_display_orientation", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 95, 0, false, Profile::Type::DisplayOrientation }, +{ 0, 0, "tap_interface", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 134, 0, false, Profile::Type::Switch }, +{ 0, 0, "tap_sensitivity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 174, 0, false, Profile::Type::TapSensitivity }, +}; + +static const Profile::FIELD userProfileFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "friendly_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "gender", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::Gender }, +{ 0, 0, "age", "years", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "height", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "weight", "kg", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "language", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::Language }, +{ 0, 0, "elev_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "weight_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "resting_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "default_max_running_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "default_max_biking_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "default_max_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "hr_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::DisplayHeart }, +{ 0, 0, "speed_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "dist_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "power_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 0, false, Profile::Type::DisplayPower }, +{ 0, 0, "activity_class", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 17, 0, false, Profile::Type::ActivityClass }, +{ 0, 0, "position_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 18, 0, false, Profile::Type::DisplayPosition }, +{ 0, 0, "temperature_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "local_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 132, false, Profile::Type::UserLocalId }, +{ 0, 0, "global_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 13, false, Profile::Type::Byte }, +{ 0, 0, "wake_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 28, 134, false, Profile::Type::LocaltimeIntoDay }, +{ 0, 0, "sleep_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 29, 134, false, Profile::Type::LocaltimeIntoDay }, +{ 0, 0, "height_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 30, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "user_running_step_length", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 31, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "user_walking_step_length", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 32, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "depth_setting", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 47, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "dive_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 49, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD hrmProfileFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Bool }, +{ 0, 0, "hrm_ant_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "log_hrv", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Bool }, +{ 0, 0, "hrm_ant_id_trans_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 10, false, Profile::Type::Uint8z }, +}; + +static const Profile::FIELD sdmProfileFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Bool }, +{ 0, 0, "sdm_ant_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "sdm_cal_factor", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "odometer", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "speed_source", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Bool }, +{ 0, 0, "sdm_ant_id_trans_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "odometer_rollover", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD bikeProfileFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::Sport }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::SubSport }, +{ 0, 0, "odometer", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "bike_spd_ant_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "bike_cad_ant_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "bike_spdcad_ant_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "bike_power_ant_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "custom_wheelsize", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 8, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "auto_wheelsize", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "bike_weight", "kg", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 10, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "power_cal_factor", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "auto_wheel_cal", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::Bool }, +{ 0, 0, "auto_power_zero", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 0, false, Profile::Type::Bool }, +{ 0, 0, "id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "spd_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 0, false, Profile::Type::Bool }, +{ 0, 0, "cad_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 0, false, Profile::Type::Bool }, +{ 0, 0, "spdcad_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 17, 0, false, Profile::Type::Bool }, +{ 0, 0, "power_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 18, 0, false, Profile::Type::Bool }, +{ 0, 0, "crank_length", "mm", (FIT_FLOAT64)2, (FIT_FLOAT64)-110, 0, 0, 19, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 20, 0, false, Profile::Type::Bool }, +{ 0, 0, "bike_spd_ant_id_trans_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "bike_cad_ant_id_trans_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "bike_spdcad_ant_id_trans_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "bike_power_ant_id_trans_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 24, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "odometer_rollover", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 37, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "front_gear_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 38, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "front_gear", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 39, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "rear_gear_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 40, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "rear_gear", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 41, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "shimano_di2_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 44, 0, false, Profile::Type::Bool }, +}; + +static const Profile::FIELD connectivityFields[] = +{ +{ 0, 0, "bluetooth_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Bool }, +{ 0, 0, "bluetooth_le_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::Bool }, +{ 0, 0, "ant_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Bool }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 7, false, Profile::Type::String }, +{ 0, 0, "live_tracking_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Bool }, +{ 0, 0, "weather_conditions_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::Bool }, +{ 0, 0, "weather_alerts_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::Bool }, +{ 0, 0, "auto_activity_upload_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::Bool }, +{ 0, 0, "course_download_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::Bool }, +{ 0, 0, "workout_download_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::Bool }, +{ 0, 0, "gps_ephemeris_download_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 0, false, Profile::Type::Bool }, +{ 0, 0, "incident_detection_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 0, false, Profile::Type::Bool }, +{ 0, 0, "grouptrack_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::Bool }, +}; + +static const Profile::SUBFIELD_MAP watchfaceSettingsLayoutDigitalLayoutMaps[] = +{ + { 0, 0 }, // mode == digital +}; + +static const Profile::SUBFIELD_MAP watchfaceSettingsLayoutAnalogLayoutMaps[] = +{ + { 1, 0 }, // mode == analog +}; + +static const Profile::SUBFIELD watchfaceSettingsLayoutSubFields[] = +{ + { watchfaceSettingsLayoutDigitalLayoutMaps, 0, "digital_layout", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, + { watchfaceSettingsLayoutAnalogLayoutMaps, 0, "analog_layout", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, +}; + +static const Profile::FIELD watchfaceSettingsFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::WatchfaceMode }, +{ 0, watchfaceSettingsLayoutSubFields, "layout", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 1, 13, false, Profile::Type::Byte }, +}; + +static const Profile::FIELD ohrSettingsFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Switch }, +}; + +static const Profile::FIELD timeInZoneFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "reference_mesg", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::MesgNum }, +{ 0, 0, "reference_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "time_in_hr_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_speed_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_cadence_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_power_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "hr_zone_high_boundary", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "speed_zone_high_boundary", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "cadence_zone_high_bondary", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "power_zone_high_boundary", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "hr_calc_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 0, false, Profile::Type::HrZoneCalc }, +{ 0, 0, "max_heart_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "resting_heart_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "threshold_heart_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "pwr_calc_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 0, false, Profile::Type::PwrZoneCalc }, +{ 0, 0, "functional_threshold_power", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD zonesTargetFields[] = +{ +{ 0, 0, "max_heart_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "threshold_heart_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "functional_threshold_power", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "hr_calc_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::HrZoneCalc }, +{ 0, 0, "pwr_calc_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::PwrZoneCalc }, +}; + +static const Profile::FIELD sportFields[] = +{ +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Sport }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::SubSport }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD hrZoneFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "high_bpm", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD speedZoneFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "high_value", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD cadenceZoneFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "high_value", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD powerZoneFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "high_value", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD metZoneFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "high_bpm", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "calories", "kcal / min", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "fat_calories", "kcal / min", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD trainingSettingsFields[] = +{ +{ 0, 0, "target_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 31, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "target_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 32, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "target_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 33, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "precise_target_speed", "m/s", (FIT_FLOAT64)1000000, (FIT_FLOAT64)0, 0, 0, 153, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::SUBFIELD_MAP diveSettingsHeartRateSourceHeartRateAntplusDeviceTypeMaps[] = +{ + { 1, 19 }, // heart_rate_source_type == antplus +}; + +static const Profile::SUBFIELD_MAP diveSettingsHeartRateSourceHeartRateLocalDeviceTypeMaps[] = +{ + { 5, 19 }, // heart_rate_source_type == local +}; + +static const Profile::SUBFIELD diveSettingsHeartRateSourceSubFields[] = +{ + { diveSettingsHeartRateSourceHeartRateAntplusDeviceTypeMaps, 0, "heart_rate_antplus_device_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, + { diveSettingsHeartRateSourceHeartRateLocalDeviceTypeMaps, 0, "heart_rate_local_device_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, +}; + +static const Profile::FIELD diveSettingsFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "model", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::TissueModelType }, +{ 0, 0, "gf_low", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "gf_high", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "water_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::WaterType }, +{ 0, 0, "water_density", "kg/m^3", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 136, false, Profile::Type::Float32 }, +{ 0, 0, "po2_warn", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "po2_critical", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 7, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "po2_deco", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 8, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "safety_stop_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::Bool }, +{ 0, 0, "bottom_depth", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 136, false, Profile::Type::Float32 }, +{ 0, 0, "bottom_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "apnea_countdown_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::Bool }, +{ 0, 0, "apnea_countdown_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "backlight_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 0, false, Profile::Type::DiveBacklightMode }, +{ 0, 0, "backlight_brightness", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "backlight_timeout", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 2, false, Profile::Type::BacklightTimeout }, +{ 0, 0, "repeat_dive_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 17, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "safety_stop_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 18, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "heart_rate_source_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 0, false, Profile::Type::SourceType }, +{ 0, diveSettingsHeartRateSourceSubFields, "heart_rate_source", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 20, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "travel_gas", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "ccr_low_setpoint_switch_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 0, false, Profile::Type::CcrSetpointSwitchMode }, +{ 0, 0, "ccr_low_setpoint", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 23, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "ccr_low_setpoint_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 24, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "ccr_high_setpoint_switch_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 25, 0, false, Profile::Type::CcrSetpointSwitchMode }, +{ 0, 0, "ccr_high_setpoint", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 26, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "ccr_high_setpoint_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 27, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "gas_consumption_display", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 29, 0, false, Profile::Type::GasConsumptionRateType }, +{ 0, 0, "up_key_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 30, 0, false, Profile::Type::Bool }, +{ 0, 0, "dive_sounds", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 35, 0, false, Profile::Type::Tone }, +{ 0, 0, "last_stop_multiple", "", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 36, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "no_fly_time_mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 37, 0, false, Profile::Type::NoFlyTimeMode }, +}; + +static const Profile::FIELD diveAlarmFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Bool }, +{ 0, 0, "alarm_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::DiveAlarmType }, +{ 0, 0, "sound", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Tone }, +{ 0, 0, "dive_types", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::SubSport }, +{ 0, 0, "id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "popup_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::Bool }, +{ 0, 0, "trigger_on_descent", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::Bool }, +{ 0, 0, "trigger_on_ascent", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::Bool }, +{ 0, 0, "repeating", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 0, false, Profile::Type::Bool }, +{ 0, 0, "speed", "mps", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 11, 133, false, Profile::Type::Sint32 }, +}; + +static const Profile::FIELD diveApneaAlarmFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Bool }, +{ 0, 0, "alarm_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::DiveAlarmType }, +{ 0, 0, "sound", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Tone }, +{ 0, 0, "dive_types", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::SubSport }, +{ 0, 0, "id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "popup_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::Bool }, +{ 0, 0, "trigger_on_descent", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::Bool }, +{ 0, 0, "trigger_on_ascent", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::Bool }, +{ 0, 0, "repeating", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 0, false, Profile::Type::Bool }, +{ 0, 0, "speed", "mps", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 11, 133, false, Profile::Type::Sint32 }, +}; + +static const Profile::FIELD diveGasFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "helium_content", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "oxygen_content", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::DiveGasStatus }, +{ 0, 0, "mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::DiveGasMode }, +}; + +static const Profile::FIELD goalFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Sport }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::SubSport }, +{ 0, 0, "start_date", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::DateTime }, +{ 0, 0, "end_date", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::DateTime }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Goal }, +{ 0, 0, "value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "repeat", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::Bool }, +{ 0, 0, "target_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "recurrence", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::GoalRecurrence }, +{ 0, 0, "recurrence_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 0, false, Profile::Type::Bool }, +{ 0, 0, "source", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 0, false, Profile::Type::GoalSource }, +}; + +static const Profile::FIELD activityFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "num_sessions", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Activity }, +{ 0, 0, "event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::Event }, +{ 0, 0, "event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::EventType }, +{ 0, 0, "local_timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::LocalDateTime }, +{ 0, 0, "event_group", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD_COMPONENT sessionAvgSpeedComponents[] = +{ + { (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 124, 16, FIT_FALSE }, // enhanced_avg_speed +}; + +static const Profile::FIELD_COMPONENT sessionMaxSpeedComponents[] = +{ + { (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 125, 16, FIT_FALSE }, // enhanced_max_speed +}; + +static const Profile::FIELD_COMPONENT sessionAvgAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 126, 16, FIT_FALSE }, // enhanced_avg_altitude +}; + +static const Profile::FIELD_COMPONENT sessionMaxAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 128, 16, FIT_FALSE }, // enhanced_max_altitude +}; + +static const Profile::FIELD_COMPONENT sessionMinAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 127, 16, FIT_FALSE }, // enhanced_min_altitude +}; + +static const Profile::FIELD_COMPONENT sessionAvgRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 169, 8, FIT_FALSE }, // enhanced_avg_respiration_rate +}; + +static const Profile::FIELD_COMPONENT sessionMaxRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 170, 8, FIT_FALSE }, // enhanced_max_respiration_rate +}; + +static const Profile::FIELD_COMPONENT sessionMinRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 180, 8, FIT_FALSE }, // enhanced_min_respiration_rate +}; + +static const Profile::SUBFIELD_MAP sessionTotalCyclesTotalStridesMaps[] = +{ + { 1, 5 }, // sport == running + { 11, 5 }, // sport == walking +}; + +static const Profile::SUBFIELD_MAP sessionTotalCyclesTotalStrokesMaps[] = +{ + { 2, 5 }, // sport == cycling + { 5, 5 }, // sport == swimming + { 15, 5 }, // sport == rowing + { 37, 5 }, // sport == stand_up_paddleboarding +}; + +static const Profile::SUBFIELD_MAP sessionAvgCadenceAvgRunningCadenceMaps[] = +{ + { 1, 5 }, // sport == running +}; + +static const Profile::SUBFIELD_MAP sessionMaxCadenceMaxRunningCadenceMaps[] = +{ + { 1, 5 }, // sport == running +}; + +static const Profile::SUBFIELD sessionTotalCyclesSubFields[] = +{ + { sessionTotalCyclesTotalStridesMaps, 0, "total_strides", "strides", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { sessionTotalCyclesTotalStrokesMaps, 0, "total_strokes", "strokes", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 134 }, +}; + +static const Profile::SUBFIELD sessionAvgCadenceSubFields[] = +{ + { sessionAvgCadenceAvgRunningCadenceMaps, 0, "avg_running_cadence", "strides/min", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, +}; + +static const Profile::SUBFIELD sessionMaxCadenceSubFields[] = +{ + { sessionMaxCadenceMaxRunningCadenceMaps, 0, "max_running_cadence", "strides/min", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, +}; + +static const Profile::FIELD sessionFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Event }, +{ 0, 0, "event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::EventType }, +{ 0, 0, "start_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::DateTime }, +{ 0, 0, "start_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "start_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::Sport }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::SubSport }, +{ 0, 0, "total_elapsed_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 8, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 9, 134, false, Profile::Type::Uint32 }, +{ 0, sessionTotalCyclesSubFields, "total_cycles", "cycles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 10, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_fat_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::Uint16 }, +{ sessionAvgSpeedComponents, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 1, 0, 14, 132, false, Profile::Type::Uint16 }, +{ sessionMaxSpeedComponents, 0, "max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 1, 0, 15, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 17, 2, false, Profile::Type::Uint8 }, +{ 0, sessionAvgCadenceSubFields, "avg_cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 18, 2, false, Profile::Type::Uint8 }, +{ 0, sessionMaxCadenceSubFields, "max_cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 19, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 20, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_ascent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_descent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_training_effect", "", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 24, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "first_lap_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 25, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "num_laps", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 26, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "event_group", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 27, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "trigger", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 28, 0, false, Profile::Type::SessionTrigger }, +{ 0, 0, "nec_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 29, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "nec_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 30, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "swc_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 31, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "swc_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 32, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "num_lengths", "lengths", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 33, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "normalized_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 34, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "training_stress_score", "tss", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 35, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "intensity_factor", "if", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 36, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "left_right_balance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 37, 132, false, Profile::Type::LeftRightBalance100 }, +{ 0, 0, "end_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 38, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 39, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "avg_stroke_count", "strokes/lap", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 41, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_stroke_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 42, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "swim_stroke", "swim_stroke", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 43, 0, false, Profile::Type::SwimStroke }, +{ 0, 0, "pool_length", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 44, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "threshold_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 45, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "pool_length_unit", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 46, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "num_active_lengths", "lengths", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 47, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_work", "J", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 48, 134, false, Profile::Type::Uint32 }, +{ sessionAvgAltitudeComponents, 0, "avg_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 49, 132, false, Profile::Type::Uint16 }, +{ sessionMaxAltitudeComponents, 0, "max_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 50, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gps_accuracy", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 51, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 52, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_pos_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 53, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_neg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 54, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_pos_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 55, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_neg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 56, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 57, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "max_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 58, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "total_moving_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 59, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_pos_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 60, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_neg_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 61, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_pos_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 62, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_neg_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 63, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "min_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 64, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "time_in_hr_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 65, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_speed_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 66, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_cadence_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 67, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_power_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 68, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_lap_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 69, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "best_lap_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 70, 132, false, Profile::Type::Uint16 }, +{ sessionMinAltitudeComponents, 0, "min_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 71, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "player_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 82, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "opponent_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 83, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "opponent_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 84, 7, false, Profile::Type::String }, +{ 0, 0, "stroke_count", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 85, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "zone_count", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 86, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_ball_speed", "m/s", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 87, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_ball_speed", "m/s", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 88, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_vertical_oscillation", "mm", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 89, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stance_time_percent", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 90, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stance_time", "ms", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 91, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 92, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 93, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_cycles", "cycles", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 94, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 95, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 96, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 97, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 98, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 99, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 100, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_left_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 101, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 102, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_left_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 103, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 104, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_combined_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 105, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "sport_profile_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 110, 7, false, Profile::Type::String }, +{ 0, 0, "sport_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 111, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "time_standing", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 112, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "stand_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 113, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_left_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 114, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "avg_right_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 115, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "avg_left_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 116, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_left_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 117, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 118, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 119, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_power_position", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 120, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_power_position", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 121, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_cadence_position", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 122, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_cadence_position", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 123, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "enhanced_avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 124, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 125, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_avg_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 126, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_min_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 127, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_max_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 128, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_lev_motor_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 129, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_lev_motor_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 130, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "lev_battery_consumption", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 131, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_vertical_ratio", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 132, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stance_time_balance", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 133, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_step_length", "mm", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 134, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_anaerobic_training_effect", "", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 137, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_vam", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 139, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 140, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 141, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "surface_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 142, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "start_cns", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 143, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "end_cns", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 144, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "start_n2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 145, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "end_n2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 146, 132, false, Profile::Type::Uint16 }, +{ sessionAvgRespirationRateComponents, 0, "avg_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 147, 2, false, Profile::Type::Uint8 }, +{ sessionMaxRespirationRateComponents, 0, "max_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 148, 2, false, Profile::Type::Uint8 }, +{ sessionMinRespirationRateComponents, 0, "min_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 149, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "min_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 150, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "o2_toxicity", "OTUs", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 155, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "dive_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 156, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "training_load_peak", "", (FIT_FLOAT64)65536, (FIT_FLOAT64)0, 0, 0, 168, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "enhanced_avg_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 169, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enhanced_max_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 170, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enhanced_min_respiration_rate", "", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 180, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_grit", "kGrit", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 181, 136, false, Profile::Type::Float32 }, +{ 0, 0, "total_flow", "Flow", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 182, 136, false, Profile::Type::Float32 }, +{ 0, 0, "jump_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 183, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_grit", "kGrit", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 186, 136, false, Profile::Type::Float32 }, +{ 0, 0, "avg_flow", "Flow", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 187, 136, false, Profile::Type::Float32 }, +{ 0, 0, "workout_feel", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 192, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "workout_rpe", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 193, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_spo2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 194, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_stress", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 195, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "sdrr_hrv", "mS", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 197, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "rmssd_hrv", "mS", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 198, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_ascent", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 199, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_descent", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 200, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 208, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 209, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 210, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD_COMPONENT lapAvgSpeedComponents[] = +{ + { (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 110, 16, FIT_FALSE }, // enhanced_avg_speed +}; + +static const Profile::FIELD_COMPONENT lapMaxSpeedComponents[] = +{ + { (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 111, 16, FIT_FALSE }, // enhanced_max_speed +}; + +static const Profile::FIELD_COMPONENT lapAvgAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 112, 16, FIT_FALSE }, // enhanced_avg_altitude +}; + +static const Profile::FIELD_COMPONENT lapMaxAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 114, 16, FIT_FALSE }, // enhanced_max_altitude +}; + +static const Profile::FIELD_COMPONENT lapMinAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 113, 16, FIT_FALSE }, // enhanced_min_altitude +}; + +static const Profile::FIELD_COMPONENT lapAvgRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 136, 8, FIT_FALSE }, // enhanced_avg_respiration_rate +}; + +static const Profile::FIELD_COMPONENT lapMaxRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 137, 8, FIT_FALSE }, // enhanced_max_respiration_rate +}; + +static const Profile::SUBFIELD_MAP lapTotalCyclesTotalStridesMaps[] = +{ + { 1, 25 }, // sport == running + { 11, 25 }, // sport == walking +}; + +static const Profile::SUBFIELD_MAP lapTotalCyclesTotalStrokesMaps[] = +{ + { 2, 25 }, // sport == cycling + { 5, 25 }, // sport == swimming + { 15, 25 }, // sport == rowing + { 37, 25 }, // sport == stand_up_paddleboarding +}; + +static const Profile::SUBFIELD_MAP lapAvgCadenceAvgRunningCadenceMaps[] = +{ + { 1, 25 }, // sport == running +}; + +static const Profile::SUBFIELD_MAP lapMaxCadenceMaxRunningCadenceMaps[] = +{ + { 1, 25 }, // sport == running +}; + +static const Profile::SUBFIELD lapTotalCyclesSubFields[] = +{ + { lapTotalCyclesTotalStridesMaps, 0, "total_strides", "strides", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { lapTotalCyclesTotalStrokesMaps, 0, "total_strokes", "strokes", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 134 }, +}; + +static const Profile::SUBFIELD lapAvgCadenceSubFields[] = +{ + { lapAvgCadenceAvgRunningCadenceMaps, 0, "avg_running_cadence", "strides/min", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, +}; + +static const Profile::SUBFIELD lapMaxCadenceSubFields[] = +{ + { lapMaxCadenceMaxRunningCadenceMaps, 0, "max_running_cadence", "strides/min", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, +}; + +static const Profile::FIELD lapFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Event }, +{ 0, 0, "event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::EventType }, +{ 0, 0, "start_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::DateTime }, +{ 0, 0, "start_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "start_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "total_elapsed_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 8, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 9, 134, false, Profile::Type::Uint32 }, +{ 0, lapTotalCyclesSubFields, "total_cycles", "cycles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 10, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_fat_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 132, false, Profile::Type::Uint16 }, +{ lapAvgSpeedComponents, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 1, 0, 13, 132, false, Profile::Type::Uint16 }, +{ lapMaxSpeedComponents, 0, "max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 1, 0, 14, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 2, false, Profile::Type::Uint8 }, +{ 0, lapAvgCadenceSubFields, "avg_cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 17, 2, false, Profile::Type::Uint8 }, +{ 0, lapMaxCadenceSubFields, "max_cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 18, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 20, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_ascent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_descent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "intensity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 0, false, Profile::Type::Intensity }, +{ 0, 0, "lap_trigger", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 24, 0, false, Profile::Type::LapTrigger }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 25, 0, false, Profile::Type::Sport }, +{ 0, 0, "event_group", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 26, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "num_lengths", "lengths", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 32, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "normalized_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 33, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "left_right_balance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 34, 132, false, Profile::Type::LeftRightBalance100 }, +{ 0, 0, "first_length_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 35, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stroke_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 37, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "swim_stroke", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 38, 0, false, Profile::Type::SwimStroke }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 39, 0, false, Profile::Type::SubSport }, +{ 0, 0, "num_active_lengths", "lengths", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 40, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_work", "J", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 41, 134, false, Profile::Type::Uint32 }, +{ lapAvgAltitudeComponents, 0, "avg_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 42, 132, false, Profile::Type::Uint16 }, +{ lapMaxAltitudeComponents, 0, "max_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 43, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gps_accuracy", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 44, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 45, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_pos_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 46, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_neg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 47, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_pos_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 48, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_neg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 49, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 50, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "max_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 51, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "total_moving_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 52, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_pos_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 53, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_neg_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 54, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_pos_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 55, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_neg_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 56, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "time_in_hr_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 57, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_speed_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 58, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_cadence_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 59, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_power_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 60, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "repetition_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 61, 132, false, Profile::Type::Uint16 }, +{ lapMinAltitudeComponents, 0, "min_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 62, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 63, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "wkt_step_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 71, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "opponent_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 74, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "stroke_count", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 75, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "zone_count", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 76, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_vertical_oscillation", "mm", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 77, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stance_time_percent", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 78, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stance_time", "ms", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 79, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 80, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 81, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_cycles", "cycles", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 82, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "player_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 83, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 84, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 85, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 86, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 87, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 88, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 89, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_left_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 91, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 92, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_left_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 93, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 94, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_combined_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 95, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "time_standing", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 98, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "stand_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 99, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_left_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 100, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "avg_right_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 101, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "avg_left_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 102, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_left_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 103, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 104, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 105, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_power_position", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 106, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_power_position", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 107, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_cadence_position", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 108, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_cadence_position", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 109, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "enhanced_avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 110, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 111, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_avg_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 112, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_min_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 113, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_max_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 114, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_lev_motor_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 115, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_lev_motor_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 116, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "lev_battery_consumption", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 117, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_vertical_ratio", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 118, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_stance_time_balance", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 119, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_step_length", "mm", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 120, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_vam", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 121, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 122, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 123, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "min_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 124, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "enhanced_avg_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 136, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enhanced_max_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 137, 132, false, Profile::Type::Uint16 }, +{ lapAvgRespirationRateComponents, 0, "avg_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 147, 2, false, Profile::Type::Uint8 }, +{ lapMaxRespirationRateComponents, 0, "max_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 148, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_grit", "kGrit", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 149, 136, false, Profile::Type::Float32 }, +{ 0, 0, "total_flow", "Flow", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 150, 136, false, Profile::Type::Float32 }, +{ 0, 0, "jump_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 151, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_grit", "kGrit", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 153, 136, false, Profile::Type::Float32 }, +{ 0, 0, "avg_flow", "Flow", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 154, 136, false, Profile::Type::Float32 }, +{ 0, 0, "total_fractional_ascent", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 156, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_descent", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 157, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 158, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 159, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 160, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD_COMPONENT lengthAvgRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 22, 8, FIT_FALSE }, // enhanced_avg_respiration_rate +}; + +static const Profile::FIELD_COMPONENT lengthMaxRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 23, 8, FIT_FALSE }, // enhanced_max_respiration_rate +}; + +static const Profile::FIELD lengthFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Event }, +{ 0, 0, "event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::EventType }, +{ 0, 0, "start_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::DateTime }, +{ 0, 0, "total_elapsed_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_strokes", "strokes", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 6, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "swim_stroke", "swim_stroke", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::SwimStroke }, +{ 0, 0, "avg_swimming_cadence", "strokes/min", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "event_group", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "length_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::LengthType }, +{ 0, 0, "player_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 18, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "opponent_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "stroke_count", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 20, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "zone_count", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enhanced_avg_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 22, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enhanced_max_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 23, 132, false, Profile::Type::Uint16 }, +{ lengthAvgRespirationRateComponents, 0, "avg_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 24, 2, false, Profile::Type::Uint8 }, +{ lengthMaxRespirationRateComponents, 0, "max_respiration_rate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 25, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD_COMPONENT recordAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 78, 16, FIT_FALSE }, // enhanced_altitude +}; + +static const Profile::FIELD_COMPONENT recordSpeedComponents[] = +{ + { (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 73, 16, FIT_FALSE }, // enhanced_speed +}; + +static const Profile::FIELD_COMPONENT recordCompressedSpeedDistanceComponents[] = +{ + { (FIT_FLOAT64)100, (FIT_FLOAT64)0, 6, 12, FIT_FALSE }, // speed + { (FIT_FLOAT64)16, (FIT_FLOAT64)0, 5, 12, FIT_TRUE }, // distance +}; + +static const Profile::FIELD_COMPONENT recordCyclesComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 19, 8, FIT_TRUE }, // total_cycles +}; + +static const Profile::FIELD_COMPONENT recordCompressedAccumulatedPowerComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 29, 16, FIT_TRUE }, // accumulated_power +}; + +static const Profile::FIELD_COMPONENT recordRespirationRateComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 108, 8, FIT_FALSE }, // enhanced_respiration_rate +}; + +static const Profile::FIELD recordFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 133, false, Profile::Type::Sint32 }, +{ recordAltitudeComponents, 0, "altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 5, 134, true, Profile::Type::Uint32 }, +{ recordSpeedComponents, 0, "speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 1, 0, 6, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::Uint16 }, +{ recordCompressedSpeedDistanceComponents, 0, "compressed_speed_distance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 0, 8, 13, false, Profile::Type::Byte }, +{ 0, 0, "grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 9, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "resistance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "time_from_course", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 11, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "cycle_length", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 12, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "speed_1s", "m/s", (FIT_FLOAT64)16, (FIT_FLOAT64)0, 0, 0, 17, 2, false, Profile::Type::Uint8 }, +{ recordCyclesComponents, 0, "cycles", "cycles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 18, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_cycles", "cycles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 134, true, Profile::Type::Uint32 }, +{ recordCompressedAccumulatedPowerComponents, 0, "compressed_accumulated_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 28, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "accumulated_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 29, 134, true, Profile::Type::Uint32 }, +{ 0, 0, "left_right_balance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 30, 2, false, Profile::Type::LeftRightBalance }, +{ 0, 0, "gps_accuracy", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 31, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 32, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 33, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "vertical_oscillation", "mm", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 39, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "stance_time_percent", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 40, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "stance_time", "ms", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 41, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "activity_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 42, 0, false, Profile::Type::ActivityType }, +{ 0, 0, "left_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 43, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "right_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 44, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "left_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 45, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "right_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 46, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "combined_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 47, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "time128", "s", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 48, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "stroke_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 49, 0, false, Profile::Type::StrokeType }, +{ 0, 0, "zone", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 50, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "ball_speed", "m/s", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 51, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "cadence256", "rpm", (FIT_FLOAT64)256, (FIT_FLOAT64)0, 0, 0, 52, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 53, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_hemoglobin_conc", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 54, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_hemoglobin_conc_min", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 55, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_hemoglobin_conc_max", "g/dL", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 56, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "saturated_hemoglobin_percent", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 57, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "saturated_hemoglobin_percent_min", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 58, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "saturated_hemoglobin_percent_max", "%", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 59, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "device_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 62, 2, false, Profile::Type::DeviceIndex }, +{ 0, 0, "left_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 67, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "right_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 68, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "left_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 69, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "left_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 70, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "right_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 71, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "right_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 72, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "enhanced_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 73, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 78, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "battery_soc", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 81, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "motor_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 82, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "vertical_ratio", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 83, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "stance_time_balance", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 84, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "step_length", "mm", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 85, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "cycle_length16", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 87, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "absolute_pressure", "Pa", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 91, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 92, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "next_stop_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 93, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "next_stop_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 94, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_to_surface", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 95, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "ndl_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 96, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "cns_load", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 97, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "n2_load", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 98, 132, false, Profile::Type::Uint16 }, +{ recordRespirationRateComponents, 0, "respiration_rate", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 99, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "enhanced_respiration_rate", "Breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 108, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "grit", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 114, 136, false, Profile::Type::Float32 }, +{ 0, 0, "flow", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 115, 136, false, Profile::Type::Float32 }, +{ 0, 0, "current_stress", "", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 116, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "ebike_travel_range", "km", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 117, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "ebike_battery_level", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 118, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "ebike_assist_mode", "depends on sensor", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 119, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "ebike_assist_level_percent", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 120, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "air_time_remaining", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 123, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "pressure_sac", "bar/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 124, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "volume_sac", "L/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 125, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "rmv", "L/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 126, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "ascent_rate", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 127, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "po2", "percent", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 129, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "core_temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 139, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD_COMPONENT eventData16Components[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 16, FIT_FALSE }, // data +}; + +static const Profile::SUBFIELD_MAP eventDataTimerTriggerMaps[] = +{ + { 0, 0 }, // event == timer +}; + +static const Profile::SUBFIELD_MAP eventDataCoursePointIndexMaps[] = +{ + { 10, 0 }, // event == course_point +}; + +static const Profile::SUBFIELD_MAP eventDataBatteryLevelMaps[] = +{ + { 11, 0 }, // event == battery +}; + +static const Profile::SUBFIELD_MAP eventDataVirtualPartnerSpeedMaps[] = +{ + { 12, 0 }, // event == virtual_partner_pace +}; + +static const Profile::SUBFIELD_MAP eventDataHrHighAlertMaps[] = +{ + { 13, 0 }, // event == hr_high_alert +}; + +static const Profile::SUBFIELD_MAP eventDataHrLowAlertMaps[] = +{ + { 14, 0 }, // event == hr_low_alert +}; + +static const Profile::SUBFIELD_MAP eventDataSpeedHighAlertMaps[] = +{ + { 15, 0 }, // event == speed_high_alert +}; + +static const Profile::SUBFIELD_MAP eventDataSpeedLowAlertMaps[] = +{ + { 16, 0 }, // event == speed_low_alert +}; + +static const Profile::SUBFIELD_MAP eventDataCadHighAlertMaps[] = +{ + { 17, 0 }, // event == cad_high_alert +}; + +static const Profile::SUBFIELD_MAP eventDataCadLowAlertMaps[] = +{ + { 18, 0 }, // event == cad_low_alert +}; + +static const Profile::SUBFIELD_MAP eventDataPowerHighAlertMaps[] = +{ + { 19, 0 }, // event == power_high_alert +}; + +static const Profile::SUBFIELD_MAP eventDataPowerLowAlertMaps[] = +{ + { 20, 0 }, // event == power_low_alert +}; + +static const Profile::SUBFIELD_MAP eventDataTimeDurationAlertMaps[] = +{ + { 23, 0 }, // event == time_duration_alert +}; + +static const Profile::SUBFIELD_MAP eventDataDistanceDurationAlertMaps[] = +{ + { 24, 0 }, // event == distance_duration_alert +}; + +static const Profile::SUBFIELD_MAP eventDataCalorieDurationAlertMaps[] = +{ + { 25, 0 }, // event == calorie_duration_alert +}; + +static const Profile::SUBFIELD_MAP eventDataFitnessEquipmentStateMaps[] = +{ + { 27, 0 }, // event == fitness_equipment +}; + +static const Profile::SUBFIELD_MAP eventDataSportPointMaps[] = +{ + { 33, 0 }, // event == sport_point +}; + +static const Profile::FIELD_COMPONENT eventDataSportPointComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 7, 16, FIT_FALSE }, // score + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 8, 16, FIT_FALSE }, // opponent_score +}; + +static const Profile::SUBFIELD_MAP eventDataGearChangeDataMaps[] = +{ + { 42, 0 }, // event == front_gear_change + { 43, 0 }, // event == rear_gear_change +}; + +static const Profile::FIELD_COMPONENT eventDataGearChangeDataComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 11, 8, FIT_FALSE }, // rear_gear_num + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 12, 8, FIT_FALSE }, // rear_gear + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 9, 8, FIT_FALSE }, // front_gear_num + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 10, 8, FIT_FALSE }, // front_gear +}; + +static const Profile::SUBFIELD_MAP eventDataRiderPositionMaps[] = +{ + { 44, 0 }, // event == rider_position_change +}; + +static const Profile::SUBFIELD_MAP eventDataCommTimeoutMaps[] = +{ + { 47, 0 }, // event == comm_timeout +}; + +static const Profile::SUBFIELD_MAP eventDataDiveAlertMaps[] = +{ + { 56, 0 }, // event == dive_alert +}; + +static const Profile::SUBFIELD_MAP eventDataAutoActivityDetectDurationMaps[] = +{ + { 54, 0 }, // event == auto_activity_detect +}; + +static const Profile::SUBFIELD_MAP eventDataRadarThreatAlertMaps[] = +{ + { 75, 0 }, // event == radar_threat_alert +}; + +static const Profile::FIELD_COMPONENT eventDataRadarThreatAlertComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 21, 8, FIT_FALSE }, // radar_threat_level_max + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 22, 8, FIT_FALSE }, // radar_threat_count + { (FIT_FLOAT64)10, (FIT_FLOAT64)0, 23, 8, FIT_FALSE }, // radar_threat_avg_approach_speed + { (FIT_FLOAT64)10, (FIT_FLOAT64)0, 24, 8, FIT_FALSE }, // radar_threat_max_approach_speed +}; + +static const Profile::SUBFIELD_MAP eventStartTimestampAutoActivityDetectStartTimestampMaps[] = +{ + { 54, 0 }, // event == auto_activity_detect +}; + +static const Profile::SUBFIELD eventDataSubFields[] = +{ + { eventDataTimerTriggerMaps, 0, "timer_trigger", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, + { eventDataCoursePointIndexMaps, 0, "course_point_index", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataBatteryLevelMaps, 0, "battery_level", "V", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataVirtualPartnerSpeedMaps, 0, "virtual_partner_speed", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataHrHighAlertMaps, 0, "hr_high_alert", "bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, + { eventDataHrLowAlertMaps, 0, "hr_low_alert", "bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, + { eventDataSpeedHighAlertMaps, 0, "speed_high_alert", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { eventDataSpeedLowAlertMaps, 0, "speed_low_alert", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { eventDataCadHighAlertMaps, 0, "cad_high_alert", "rpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataCadLowAlertMaps, 0, "cad_low_alert", "rpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataPowerHighAlertMaps, 0, "power_high_alert", "watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataPowerLowAlertMaps, 0, "power_low_alert", "watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataTimeDurationAlertMaps, 0, "time_duration_alert", "s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { eventDataDistanceDurationAlertMaps, 0, "distance_duration_alert", "m", (FIT_FLOAT32)100, (FIT_FLOAT32)0, 1, 0, 134 }, + { eventDataCalorieDurationAlertMaps, 0, "calorie_duration_alert", "calories", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { eventDataFitnessEquipmentStateMaps, 0, "fitness_equipment_state", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, + { eventDataSportPointMaps, eventDataSportPointComponents, "sport_point", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 2, 134 }, + { eventDataGearChangeDataMaps, eventDataGearChangeDataComponents, "gear_change_data", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 4, 134 }, + { eventDataRiderPositionMaps, 0, "rider_position", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, + { eventDataCommTimeoutMaps, 0, "comm_timeout", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataDiveAlertMaps, 0, "dive_alert", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, + { eventDataAutoActivityDetectDurationMaps, 0, "auto_activity_detect_duration", "min", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { eventDataRadarThreatAlertMaps, eventDataRadarThreatAlertComponents, "radar_threat_alert", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 4, 134 }, +}; + +static const Profile::SUBFIELD eventStartTimestampSubFields[] = +{ + { eventStartTimestampAutoActivityDetectStartTimestampMaps, 0, "auto_activity_detect_start_timestamp", "s", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::FIELD eventFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Event }, +{ 0, 0, "event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::EventType }, +{ eventData16Components, 0, "data16", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 1, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, eventDataSubFields, "data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 23, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "event_group", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "opponent_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "front_gear_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "front_gear", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "rear_gear_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "rear_gear", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "device_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 2, false, Profile::Type::DeviceIndex }, +{ 0, 0, "activity_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 0, false, Profile::Type::ActivityType }, +{ 0, eventStartTimestampSubFields, "start_timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 15, 134, false, Profile::Type::DateTime }, +{ 0, 0, "radar_threat_level_max", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 0, false, Profile::Type::RadarThreatLevelType }, +{ 0, 0, "radar_threat_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "radar_threat_avg_approach_speed", "m/s", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 23, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "radar_threat_max_approach_speed", "m/s", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 24, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::SUBFIELD_MAP deviceInfoDeviceTypeBleDeviceTypeMaps[] = +{ + { 3, 25 }, // source_type == bluetooth_low_energy +}; + +static const Profile::SUBFIELD_MAP deviceInfoDeviceTypeAntplusDeviceTypeMaps[] = +{ + { 1, 25 }, // source_type == antplus +}; + +static const Profile::SUBFIELD_MAP deviceInfoDeviceTypeAntDeviceTypeMaps[] = +{ + { 0, 25 }, // source_type == ant +}; + +static const Profile::SUBFIELD_MAP deviceInfoDeviceTypeLocalDeviceTypeMaps[] = +{ + { 5, 25 }, // source_type == local +}; + +static const Profile::SUBFIELD_MAP deviceInfoProductFaveroProductMaps[] = +{ + { 263, 2 }, // manufacturer == favero_electronics +}; + +static const Profile::SUBFIELD_MAP deviceInfoProductGarminProductMaps[] = +{ + { 1, 2 }, // manufacturer == garmin + { 15, 2 }, // manufacturer == dynastream + { 13, 2 }, // manufacturer == dynastream_oem + { 89, 2 }, // manufacturer == tacx +}; + +static const Profile::SUBFIELD deviceInfoDeviceTypeSubFields[] = +{ + { deviceInfoDeviceTypeBleDeviceTypeMaps, 0, "ble_device_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, + { deviceInfoDeviceTypeAntplusDeviceTypeMaps, 0, "antplus_device_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, + { deviceInfoDeviceTypeAntDeviceTypeMaps, 0, "ant_device_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, + { deviceInfoDeviceTypeLocalDeviceTypeMaps, 0, "local_device_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 2 }, +}; + +static const Profile::SUBFIELD deviceInfoProductSubFields[] = +{ + { deviceInfoProductFaveroProductMaps, 0, "favero_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { deviceInfoProductGarminProductMaps, 0, "garmin_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 132 }, +}; + +static const Profile::FIELD deviceInfoFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "device_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::DeviceIndex }, +{ 0, deviceInfoDeviceTypeSubFields, "device_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 4, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "manufacturer", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Manufacturer }, +{ 0, 0, "serial_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 140, false, Profile::Type::Uint32z }, +{ 0, deviceInfoProductSubFields, "product", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "software_version", "", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "hardware_version", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "cum_operating_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "battery_voltage", "V", (FIT_FLOAT64)256, (FIT_FLOAT64)0, 0, 0, 10, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "battery_status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::BatteryStatus }, +{ 0, 0, "sensor_position", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 18, 0, false, Profile::Type::BodyLocation }, +{ 0, 0, "descriptor", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 7, false, Profile::Type::String }, +{ 0, 0, "ant_transmission_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 20, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "ant_device_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "ant_network", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 0, false, Profile::Type::AntNetwork }, +{ 0, 0, "source_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 25, 0, false, Profile::Type::SourceType }, +{ 0, 0, "product_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 27, 7, false, Profile::Type::String }, +{ 0, 0, "battery_level", "%", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 32, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD deviceAuxBatteryInfoFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "device_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::DeviceIndex }, +{ 0, 0, "battery_voltage", "V", (FIT_FLOAT64)256, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "battery_status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::BatteryStatus }, +{ 0, 0, "battery_identifier", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::SUBFIELD_MAP trainingFileProductFaveroProductMaps[] = +{ + { 263, 1 }, // manufacturer == favero_electronics +}; + +static const Profile::SUBFIELD_MAP trainingFileProductGarminProductMaps[] = +{ + { 1, 1 }, // manufacturer == garmin + { 15, 1 }, // manufacturer == dynastream + { 13, 1 }, // manufacturer == dynastream_oem + { 89, 1 }, // manufacturer == tacx +}; + +static const Profile::SUBFIELD trainingFileProductSubFields[] = +{ + { trainingFileProductFaveroProductMaps, 0, "favero_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { trainingFileProductGarminProductMaps, 0, "garmin_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 132 }, +}; + +static const Profile::FIELD trainingFileFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::File }, +{ 0, 0, "manufacturer", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Manufacturer }, +{ 0, trainingFileProductSubFields, "product", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "serial_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 140, false, Profile::Type::Uint32z }, +{ 0, 0, "time_created", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::DateTime }, +}; + +static const Profile::FIELD weatherConditionsFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "weather_report", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::WeatherReport }, +{ 0, 0, "temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "condition", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::WeatherStatus }, +{ 0, 0, "wind_direction", "degrees", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "wind_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "precipitation_probability", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "temperature_feels_like", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "relative_humidity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "location", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 7, false, Profile::Type::String }, +{ 0, 0, "observed_at_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 134, false, Profile::Type::DateTime }, +{ 0, 0, "observed_location_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "observed_location_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "day_of_week", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::DayOfWeek }, +{ 0, 0, "high_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "low_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 1, false, Profile::Type::Sint8 }, +}; + +static const Profile::FIELD weatherAlertFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "report_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "issue_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::DateTime }, +{ 0, 0, "expire_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::DateTime }, +{ 0, 0, "severity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::WeatherSeverity }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::WeatherSevereType }, +}; + +static const Profile::FIELD gpsMetadataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "enhanced_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "heading", "degrees", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "utc_timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::DateTime }, +{ 0, 0, "velocity", "m/s", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 7, 131, false, Profile::Type::Sint16 }, +}; + +static const Profile::FIELD cameraEventFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "camera_event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::CameraEventType }, +{ 0, 0, "camera_file_uuid", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 7, false, Profile::Type::String }, +{ 0, 0, "camera_orientation", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::CameraOrientationType }, +}; + +static const Profile::FIELD gyroscopeDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sample_time_offset", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gyro_x", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gyro_y", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gyro_z", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "calibrated_gyro_x", "deg/s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 136, false, Profile::Type::Float32 }, +{ 0, 0, "calibrated_gyro_y", "deg/s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 136, false, Profile::Type::Float32 }, +{ 0, 0, "calibrated_gyro_z", "deg/s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 136, false, Profile::Type::Float32 }, +}; + +static const Profile::FIELD accelerometerDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sample_time_offset", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "accel_x", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "accel_y", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "accel_z", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "calibrated_accel_x", "g", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 136, false, Profile::Type::Float32 }, +{ 0, 0, "calibrated_accel_y", "g", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 136, false, Profile::Type::Float32 }, +{ 0, 0, "calibrated_accel_z", "g", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 136, false, Profile::Type::Float32 }, +{ 0, 0, "compressed_calibrated_accel_x", "mG", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "compressed_calibrated_accel_y", "mG", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "compressed_calibrated_accel_z", "mG", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 131, false, Profile::Type::Sint16 }, +}; + +static const Profile::FIELD magnetometerDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sample_time_offset", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "mag_x", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "mag_y", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "mag_z", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "calibrated_mag_x", "G", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 136, false, Profile::Type::Float32 }, +{ 0, 0, "calibrated_mag_y", "G", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 136, false, Profile::Type::Float32 }, +{ 0, 0, "calibrated_mag_z", "G", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 136, false, Profile::Type::Float32 }, +}; + +static const Profile::FIELD barometerDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sample_time_offset", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "baro_pres", "Pa", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::SUBFIELD_MAP threeDSensorCalibrationCalibrationFactorAccelCalFactorMaps[] = +{ + { 0, 0 }, // sensor_type == accelerometer +}; + +static const Profile::SUBFIELD_MAP threeDSensorCalibrationCalibrationFactorGyroCalFactorMaps[] = +{ + { 1, 0 }, // sensor_type == gyroscope +}; + +static const Profile::SUBFIELD threeDSensorCalibrationCalibrationFactorSubFields[] = +{ + { threeDSensorCalibrationCalibrationFactorAccelCalFactorMaps, 0, "accel_cal_factor", "g", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { threeDSensorCalibrationCalibrationFactorGyroCalFactorMaps, 0, "gyro_cal_factor", "deg/s", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::FIELD threeDSensorCalibrationFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "sensor_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SensorType }, +{ 0, threeDSensorCalibrationCalibrationFactorSubFields, "calibration_factor", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "calibration_divisor", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "level_shift", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "offset_cal", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "orientation_matrix", "", (FIT_FLOAT64)65535, (FIT_FLOAT64)0, 0, 0, 5, 133, false, Profile::Type::Sint32 }, +}; + +static const Profile::SUBFIELD_MAP oneDSensorCalibrationCalibrationFactorBaroCalFactorMaps[] = +{ + { 3, 0 }, // sensor_type == barometer +}; + +static const Profile::SUBFIELD oneDSensorCalibrationCalibrationFactorSubFields[] = +{ + { oneDSensorCalibrationCalibrationFactorBaroCalFactorMaps, 0, "baro_cal_factor", "Pa", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::FIELD oneDSensorCalibrationFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "sensor_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SensorType }, +{ 0, oneDSensorCalibrationCalibrationFactorSubFields, "calibration_factor", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "calibration_divisor", "counts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "level_shift", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "offset_cal", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 133, false, Profile::Type::Sint32 }, +}; + +static const Profile::FIELD videoFrameFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "frame_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD obdiiDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "time_offset", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "pid", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 13, false, Profile::Type::Byte }, +{ 0, 0, "raw_data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 13, false, Profile::Type::Byte }, +{ 0, 0, "pid_data_size", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "system_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "start_timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::DateTime }, +{ 0, 0, "start_timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD nmeaSentenceFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sentence", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD aviationAttitudeFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "system_time", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "pitch", "radians", (FIT_FLOAT64)10430.38, (FIT_FLOAT64)0, 0, 0, 2, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "roll", "radians", (FIT_FLOAT64)10430.38, (FIT_FLOAT64)0, 0, 0, 3, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "accel_lateral", "m/s^2", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 4, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "accel_normal", "m/s^2", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 5, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "turn_rate", "radians/second", (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 0, 0, 6, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "stage", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::AttitudeStage }, +{ 0, 0, "attitude_stage_complete", "%", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "track", "radians", (FIT_FLOAT64)10430.38, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "validity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 132, false, Profile::Type::AttitudeValidity }, +}; + +static const Profile::FIELD videoFields[] = +{ +{ 0, 0, "url", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "hosting_provider", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +{ 0, 0, "duration", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD videoTitleFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "message_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "text", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD videoDescriptionFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "message_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "text", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD videoClipFields[] = +{ +{ 0, 0, "clip_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "start_timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::DateTime }, +{ 0, 0, "start_timestamp_ms", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "end_timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::DateTime }, +{ 0, 0, "end_timestamp_ms", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "clip_start", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "clip_end", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD setFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 134, false, Profile::Type::DateTime }, +{ 0, 0, "duration", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "repetitions", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "weight", "kg", (FIT_FLOAT64)16, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "set_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 2, false, Profile::Type::SetType }, +{ 0, 0, "start_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::DateTime }, +{ 0, 0, "category", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::ExerciseCategory }, +{ 0, 0, "category_subtype", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "weight_display_unit", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::FitBaseUnit }, +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "wkt_step_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::MessageIndex }, +}; + +static const Profile::FIELD_COMPONENT jumpSpeedComponents[] = +{ + { (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 8, 16, FIT_FALSE }, // enhanced_speed +}; + +static const Profile::FIELD jumpFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "distance", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 136, false, Profile::Type::Float32 }, +{ 0, 0, "height", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 136, false, Profile::Type::Float32 }, +{ 0, 0, "rotations", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "hang_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 136, false, Profile::Type::Float32 }, +{ 0, 0, "score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 136, false, Profile::Type::Float32 }, +{ 0, 0, "position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 133, false, Profile::Type::Sint32 }, +{ jumpSpeedComponents, 0, "speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 1, 0, 7, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "enhanced_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 8, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD splitFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "split_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SplitType }, +{ 0, 0, "total_elapsed_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "start_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 134, false, Profile::Type::DateTime }, +{ 0, 0, "total_ascent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_descent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "start_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "start_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 24, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 25, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_vert_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 26, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 27, 134, false, Profile::Type::DateTime }, +{ 0, 0, "total_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 28, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "start_elevation", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 74, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_moving_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 110, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD splitSummaryFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "split_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SplitType }, +{ 0, 0, "num_splits", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_ascent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_descent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_vert_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 12, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "total_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_moving_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 77, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD climbProFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "climb_pro_event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::ClimbProEvent }, +{ 0, 0, "climb_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "climb_category", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "current_dist", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 136, false, Profile::Type::Float32 }, +}; + +static const Profile::FIELD fieldDescriptionFields[] = +{ +{ 0, 0, "developer_data_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "field_definition_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "fit_base_type_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::FitBaseType }, +{ 0, 0, "field_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 7, false, Profile::Type::String }, +{ 0, 0, "array", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "components", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 7, false, Profile::Type::String }, +{ 0, 0, "scale", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "offset", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "units", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 7, false, Profile::Type::String }, +{ 0, 0, "bits", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 7, false, Profile::Type::String }, +{ 0, 0, "accumulate", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 7, false, Profile::Type::String }, +{ 0, 0, "fit_base_unit_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::FitBaseUnit }, +{ 0, 0, "native_mesg_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 132, false, Profile::Type::MesgNum }, +{ 0, 0, "native_field_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD developerDataIdFields[] = +{ +{ 0, 0, "developer_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 13, false, Profile::Type::Byte }, +{ 0, 0, "application_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 13, false, Profile::Type::Byte }, +{ 0, 0, "manufacturer_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Manufacturer }, +{ 0, 0, "developer_data_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "application_version", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD courseFields[] = +{ +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Sport }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 7, false, Profile::Type::String }, +{ 0, 0, "capabilities", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 140, false, Profile::Type::CourseCapabilities }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::SubSport }, +}; + +static const Profile::FIELD coursePointFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::DateTime }, +{ 0, 0, "position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::CoursePoint }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 7, false, Profile::Type::String }, +{ 0, 0, "favorite", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::Bool }, +}; + +static const Profile::FIELD segmentIdFields[] = +{ +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "uuid", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Sport }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::Bool }, +{ 0, 0, "user_profile_primary_key", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "device_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "default_race_leader", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "delete_status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::SegmentDeleteStatus }, +{ 0, 0, "selection_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::SegmentSelectionType }, +}; + +static const Profile::FIELD segmentLeaderboardEntryFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::SegmentLeaderboardType }, +{ 0, 0, "group_primary_key", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "activity_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "segment_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "activity_id_string", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD_COMPONENT segmentPointAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 6, 16, FIT_FALSE }, // enhanced_altitude +}; + +static const Profile::FIELD segmentPointFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ segmentPointAltitudeComponents, 0, "altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "leader_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD_COMPONENT segmentLapAvgAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 91, 16, FIT_FALSE }, // enhanced_avg_altitude +}; + +static const Profile::FIELD_COMPONENT segmentLapMaxAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 92, 16, FIT_FALSE }, // enhanced_max_altitude +}; + +static const Profile::FIELD_COMPONENT segmentLapMinAltitudeComponents[] = +{ + { (FIT_FLOAT64)5, (FIT_FLOAT64)500, 93, 16, FIT_FALSE }, // enhanced_min_altitude +}; + +static const Profile::SUBFIELD_MAP segmentLapTotalCyclesTotalStrokesMaps[] = +{ + { 2, 23 }, // sport == cycling +}; + +static const Profile::SUBFIELD segmentLapTotalCyclesSubFields[] = +{ + { segmentLapTotalCyclesTotalStrokesMaps, 0, "total_strokes", "strokes", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::FIELD segmentLapFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Event }, +{ 0, 0, "event_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::EventType }, +{ 0, 0, "start_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::DateTime }, +{ 0, 0, "start_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "start_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "end_position_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "total_elapsed_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 7, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_timer_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 8, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 9, 134, false, Profile::Type::Uint32 }, +{ 0, segmentLapTotalCyclesSubFields, "total_cycles", "cycles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 1, 10, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "total_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_fat_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 14, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 17, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_cadence", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 18, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 20, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_ascent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 21, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "total_descent", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 22, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 23, 0, false, Profile::Type::Sport }, +{ 0, 0, "event_group", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 24, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "nec_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 25, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "nec_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 26, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "swc_lat", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 27, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "swc_long", "semicircles", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 28, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 29, 7, false, Profile::Type::String }, +{ 0, 0, "normalized_power", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 30, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "left_right_balance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 31, 132, false, Profile::Type::LeftRightBalance100 }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 32, 0, false, Profile::Type::SubSport }, +{ 0, 0, "total_work", "J", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 33, 134, false, Profile::Type::Uint32 }, +{ segmentLapAvgAltitudeComponents, 0, "avg_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 34, 132, false, Profile::Type::Uint16 }, +{ segmentLapMaxAltitudeComponents, 0, "max_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 35, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gps_accuracy", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 36, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 37, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_pos_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 38, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_neg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 39, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_pos_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 40, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_neg_grade", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 41, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 42, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "max_temperature", "C", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 43, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "total_moving_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 44, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_pos_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 45, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "avg_neg_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 46, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_pos_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 47, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "max_neg_vertical_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 48, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "time_in_hr_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 49, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_speed_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 50, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_cadence_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 51, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "time_in_power_zone", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 52, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "repetition_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 53, 132, false, Profile::Type::Uint16 }, +{ segmentLapMinAltitudeComponents, 0, "min_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 1, 0, 54, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "min_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 55, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "active_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 56, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "wkt_step_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 57, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "sport_event", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 58, 0, false, Profile::Type::SportEvent }, +{ 0, 0, "avg_left_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 59, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_torque_effectiveness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 60, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_left_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 61, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 62, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_combined_pedal_smoothness", "percent", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 0, 63, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 64, 0, false, Profile::Type::SegmentLapStatus }, +{ 0, 0, "uuid", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 65, 7, false, Profile::Type::String }, +{ 0, 0, "avg_fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 66, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_fractional_cadence", "rpm", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 67, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_cycles", "cycles", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 68, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "front_gear_shift_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 69, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "rear_gear_shift_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 70, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "time_standing", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 71, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "stand_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 72, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_left_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 73, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "avg_right_pco", "mm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 74, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "avg_left_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 75, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_left_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 76, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_power_phase", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 77, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_right_power_phase_peak", "degrees", (FIT_FLOAT64)0.7111111, (FIT_FLOAT64)0, 0, 0, 78, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "avg_power_position", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 79, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "max_power_position", "watts", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 80, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_cadence_position", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 81, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "max_cadence_position", "rpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 82, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "manufacturer", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 83, 132, false, Profile::Type::Manufacturer }, +{ 0, 0, "total_grit", "kGrit", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 84, 136, false, Profile::Type::Float32 }, +{ 0, 0, "total_flow", "Flow", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 85, 136, false, Profile::Type::Float32 }, +{ 0, 0, "avg_grit", "kGrit", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 86, 136, false, Profile::Type::Float32 }, +{ 0, 0, "avg_flow", "Flow", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 87, 136, false, Profile::Type::Float32 }, +{ 0, 0, "total_fractional_ascent", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 89, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "total_fractional_descent", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 90, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "enhanced_avg_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 91, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_max_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 92, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "enhanced_min_altitude", "m", (FIT_FLOAT64)5, (FIT_FLOAT64)500, 0, 0, 93, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD segmentFileFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "file_uuid", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 7, false, Profile::Type::String }, +{ 0, 0, "enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::Bool }, +{ 0, 0, "user_profile_primary_key", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "leader_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::SegmentLeaderboardType }, +{ 0, 0, "leader_group_primary_key", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "leader_activity_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "leader_activity_id_string", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 7, false, Profile::Type::String }, +{ 0, 0, "default_race_leader", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD workoutFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Sport }, +{ 0, 0, "capabilities", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 140, false, Profile::Type::WorkoutCapabilities }, +{ 0, 0, "num_valid_steps", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "wkt_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 7, false, Profile::Type::String }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 0, false, Profile::Type::SubSport }, +{ 0, 0, "pool_length", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 14, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "pool_length_unit", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 15, 0, false, Profile::Type::DisplayMeasure }, +{ 0, 0, "wkt_description", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 17, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD workoutSessionFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::Sport }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::SubSport }, +{ 0, 0, "num_valid_steps", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "first_step_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "pool_length", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "pool_length_unit", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::DisplayMeasure }, +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationTimeMaps[] = +{ + { 0, 1 }, // duration_type == time + { 28, 1 }, // duration_type == repetition_time +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationDistanceMaps[] = +{ + { 1, 1 }, // duration_type == distance +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationHrMaps[] = +{ + { 2, 1 }, // duration_type == hr_less_than + { 3, 1 }, // duration_type == hr_greater_than +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationCaloriesMaps[] = +{ + { 4, 1 }, // duration_type == calories +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationStepMaps[] = +{ + { 6, 1 }, // duration_type == repeat_until_steps_cmplt + { 7, 1 }, // duration_type == repeat_until_time + { 8, 1 }, // duration_type == repeat_until_distance + { 9, 1 }, // duration_type == repeat_until_calories + { 10, 1 }, // duration_type == repeat_until_hr_less_than + { 11, 1 }, // duration_type == repeat_until_hr_greater_than + { 12, 1 }, // duration_type == repeat_until_power_less_than + { 13, 1 }, // duration_type == repeat_until_power_greater_than +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationPowerMaps[] = +{ + { 14, 1 }, // duration_type == power_less_than + { 15, 1 }, // duration_type == power_greater_than +}; + +static const Profile::SUBFIELD_MAP workoutStepDurationValueDurationRepsMaps[] = +{ + { 29, 1 }, // duration_type == reps +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueTargetSpeedZoneMaps[] = +{ + { 0, 3 }, // target_type == speed +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueTargetHrZoneMaps[] = +{ + { 1, 3 }, // target_type == heart_rate +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueTargetCadenceZoneMaps[] = +{ + { 3, 3 }, // target_type == cadence +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueTargetPowerZoneMaps[] = +{ + { 4, 3 }, // target_type == power +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueRepeatStepsMaps[] = +{ + { 6, 1 }, // duration_type == repeat_until_steps_cmplt +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueRepeatTimeMaps[] = +{ + { 7, 1 }, // duration_type == repeat_until_time +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueRepeatDistanceMaps[] = +{ + { 8, 1 }, // duration_type == repeat_until_distance +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueRepeatCaloriesMaps[] = +{ + { 9, 1 }, // duration_type == repeat_until_calories +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueRepeatHrMaps[] = +{ + { 10, 1 }, // duration_type == repeat_until_hr_less_than + { 11, 1 }, // duration_type == repeat_until_hr_greater_than +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueRepeatPowerMaps[] = +{ + { 12, 1 }, // duration_type == repeat_until_power_less_than + { 13, 1 }, // duration_type == repeat_until_power_greater_than +}; + +static const Profile::SUBFIELD_MAP workoutStepTargetValueTargetStrokeTypeMaps[] = +{ + { 11, 3 }, // target_type == swim_stroke +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueLowCustomTargetSpeedLowMaps[] = +{ + { 0, 3 }, // target_type == speed +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueLowCustomTargetHeartRateLowMaps[] = +{ + { 1, 3 }, // target_type == heart_rate +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueLowCustomTargetCadenceLowMaps[] = +{ + { 3, 3 }, // target_type == cadence +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueLowCustomTargetPowerLowMaps[] = +{ + { 4, 3 }, // target_type == power +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueHighCustomTargetSpeedHighMaps[] = +{ + { 0, 3 }, // target_type == speed +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueHighCustomTargetHeartRateHighMaps[] = +{ + { 1, 3 }, // target_type == heart_rate +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueHighCustomTargetCadenceHighMaps[] = +{ + { 3, 3 }, // target_type == cadence +}; + +static const Profile::SUBFIELD_MAP workoutStepCustomTargetValueHighCustomTargetPowerHighMaps[] = +{ + { 4, 3 }, // target_type == power +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryTargetValueSecondaryTargetSpeedZoneMaps[] = +{ + { 0, 19 }, // secondary_target_type == speed +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryTargetValueSecondaryTargetHrZoneMaps[] = +{ + { 1, 19 }, // secondary_target_type == heart_rate +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryTargetValueSecondaryTargetCadenceZoneMaps[] = +{ + { 3, 19 }, // secondary_target_type == cadence +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryTargetValueSecondaryTargetPowerZoneMaps[] = +{ + { 4, 19 }, // secondary_target_type == power +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryTargetValueSecondaryTargetStrokeTypeMaps[] = +{ + { 11, 19 }, // secondary_target_type == swim_stroke +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetSpeedLowMaps[] = +{ + { 0, 19 }, // secondary_target_type == speed +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetHeartRateLowMaps[] = +{ + { 1, 19 }, // secondary_target_type == heart_rate +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetCadenceLowMaps[] = +{ + { 3, 19 }, // secondary_target_type == cadence +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetPowerLowMaps[] = +{ + { 4, 19 }, // secondary_target_type == power +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetSpeedHighMaps[] = +{ + { 0, 19 }, // secondary_target_type == speed +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetHeartRateHighMaps[] = +{ + { 1, 19 }, // secondary_target_type == heart_rate +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetCadenceHighMaps[] = +{ + { 3, 19 }, // secondary_target_type == cadence +}; + +static const Profile::SUBFIELD_MAP workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetPowerHighMaps[] = +{ + { 4, 19 }, // secondary_target_type == power +}; + +static const Profile::SUBFIELD workoutStepDurationValueSubFields[] = +{ + { workoutStepDurationValueDurationTimeMaps, 0, "duration_time", "s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 2, 0, 134 }, + { workoutStepDurationValueDurationDistanceMaps, 0, "duration_distance", "m", (FIT_FLOAT32)100, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepDurationValueDurationHrMaps, 0, "duration_hr", "% or bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { workoutStepDurationValueDurationCaloriesMaps, 0, "duration_calories", "calories", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepDurationValueDurationStepMaps, 0, "duration_step", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 8, 0, 134 }, + { workoutStepDurationValueDurationPowerMaps, 0, "duration_power", "% or watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { workoutStepDurationValueDurationRepsMaps, 0, "duration_reps", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::SUBFIELD workoutStepTargetValueSubFields[] = +{ + { workoutStepTargetValueTargetSpeedZoneMaps, 0, "target_speed_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueTargetHrZoneMaps, 0, "target_hr_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueTargetCadenceZoneMaps, 0, "target_cadence_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueTargetPowerZoneMaps, 0, "target_power_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueRepeatStepsMaps, 0, "repeat_steps", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueRepeatTimeMaps, 0, "repeat_time", "s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueRepeatDistanceMaps, 0, "repeat_distance", "m", (FIT_FLOAT32)100, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueRepeatCaloriesMaps, 0, "repeat_calories", "calories", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepTargetValueRepeatHrMaps, 0, "repeat_hr", "% or bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { workoutStepTargetValueRepeatPowerMaps, 0, "repeat_power", "% or watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { workoutStepTargetValueTargetStrokeTypeMaps, 0, "target_stroke_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, +}; + +static const Profile::SUBFIELD workoutStepCustomTargetValueLowSubFields[] = +{ + { workoutStepCustomTargetValueLowCustomTargetSpeedLowMaps, 0, "custom_target_speed_low", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepCustomTargetValueLowCustomTargetHeartRateLowMaps, 0, "custom_target_heart_rate_low", "% or bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepCustomTargetValueLowCustomTargetCadenceLowMaps, 0, "custom_target_cadence_low", "rpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepCustomTargetValueLowCustomTargetPowerLowMaps, 0, "custom_target_power_low", "% or watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::SUBFIELD workoutStepCustomTargetValueHighSubFields[] = +{ + { workoutStepCustomTargetValueHighCustomTargetSpeedHighMaps, 0, "custom_target_speed_high", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepCustomTargetValueHighCustomTargetHeartRateHighMaps, 0, "custom_target_heart_rate_high", "% or bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepCustomTargetValueHighCustomTargetCadenceHighMaps, 0, "custom_target_cadence_high", "rpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepCustomTargetValueHighCustomTargetPowerHighMaps, 0, "custom_target_power_high", "% or watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::SUBFIELD workoutStepSecondaryTargetValueSubFields[] = +{ + { workoutStepSecondaryTargetValueSecondaryTargetSpeedZoneMaps, 0, "secondary_target_speed_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryTargetValueSecondaryTargetHrZoneMaps, 0, "secondary_target_hr_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryTargetValueSecondaryTargetCadenceZoneMaps, 0, "secondary_target_cadence_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryTargetValueSecondaryTargetPowerZoneMaps, 0, "secondary_target_power_zone", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryTargetValueSecondaryTargetStrokeTypeMaps, 0, "secondary_target_stroke_type", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 0 }, +}; + +static const Profile::SUBFIELD workoutStepSecondaryCustomTargetValueLowSubFields[] = +{ + { workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetSpeedLowMaps, 0, "secondary_custom_target_speed_low", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetHeartRateLowMaps, 0, "secondary_custom_target_heart_rate_low", "% or bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetCadenceLowMaps, 0, "secondary_custom_target_cadence_low", "rpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryCustomTargetValueLowSecondaryCustomTargetPowerLowMaps, 0, "secondary_custom_target_power_low", "% or watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::SUBFIELD workoutStepSecondaryCustomTargetValueHighSubFields[] = +{ + { workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetSpeedHighMaps, 0, "secondary_custom_target_speed_high", "m/s", (FIT_FLOAT32)1000, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetHeartRateHighMaps, 0, "secondary_custom_target_heart_rate_high", "% or bpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetCadenceHighMaps, 0, "secondary_custom_target_cadence_high", "rpm", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, + { workoutStepSecondaryCustomTargetValueHighSecondaryCustomTargetPowerHighMaps, 0, "secondary_custom_target_power_high", "% or watts", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 134 }, +}; + +static const Profile::FIELD workoutStepFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "wkt_step_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 7, false, Profile::Type::String }, +{ 0, 0, "duration_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::WktStepDuration }, +{ 0, workoutStepDurationValueSubFields, "duration_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 7, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "target_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::WktStepTarget }, +{ 0, workoutStepTargetValueSubFields, "target_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 11, 4, 134, false, Profile::Type::Uint32 }, +{ 0, workoutStepCustomTargetValueLowSubFields, "custom_target_value_low", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 4, 5, 134, false, Profile::Type::Uint32 }, +{ 0, workoutStepCustomTargetValueHighSubFields, "custom_target_value_high", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 4, 6, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "intensity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::Intensity }, +{ 0, 0, "notes", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 7, false, Profile::Type::String }, +{ 0, 0, "equipment", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::WorkoutEquipment }, +{ 0, 0, "exercise_category", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 132, false, Profile::Type::ExerciseCategory }, +{ 0, 0, "exercise_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "exercise_weight", "kg", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 12, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "weight_display_unit", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::FitBaseUnit }, +{ 0, 0, "secondary_target_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 0, false, Profile::Type::WktStepTarget }, +{ 0, workoutStepSecondaryTargetValueSubFields, "secondary_target_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 5, 20, 134, false, Profile::Type::Uint32 }, +{ 0, workoutStepSecondaryCustomTargetValueLowSubFields, "secondary_custom_target_value_low", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 4, 21, 134, false, Profile::Type::Uint32 }, +{ 0, workoutStepSecondaryCustomTargetValueHighSubFields, "secondary_custom_target_value_high", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 4, 22, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD exerciseTitleFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "exercise_category", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::ExerciseCategory }, +{ 0, 0, "exercise_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "wkt_step_name", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 7, false, Profile::Type::String }, +}; + +static const Profile::SUBFIELD_MAP scheduleProductFaveroProductMaps[] = +{ + { 263, 0 }, // manufacturer == favero_electronics +}; + +static const Profile::SUBFIELD_MAP scheduleProductGarminProductMaps[] = +{ + { 1, 0 }, // manufacturer == garmin + { 15, 0 }, // manufacturer == dynastream + { 13, 0 }, // manufacturer == dynastream_oem + { 89, 0 }, // manufacturer == tacx +}; + +static const Profile::SUBFIELD scheduleProductSubFields[] = +{ + { scheduleProductFaveroProductMaps, 0, "favero_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 1, 0, 132 }, + { scheduleProductGarminProductMaps, 0, "garmin_product", "", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 4, 0, 132 }, +}; + +static const Profile::FIELD scheduleFields[] = +{ +{ 0, 0, "manufacturer", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Manufacturer }, +{ 0, scheduleProductSubFields, "product", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 2, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "serial_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 140, false, Profile::Type::Uint32z }, +{ 0, 0, "time_created", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::DateTime }, +{ 0, 0, "completed", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::Bool }, +{ 0, 0, "type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::Schedule }, +{ 0, 0, "scheduled_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::LocalDateTime }, +}; + +static const Profile::FIELD totalsFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timer_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "distance", "m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::Sport }, +{ 0, 0, "elapsed_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "sessions", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "active_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "sport_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD weightScaleFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "weight", "kg", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Weight }, +{ 0, 0, "percent_fat", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "percent_hydration", "%", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "visceral_fat_mass", "kg", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "bone_mass", "kg", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "muscle_mass", "kg", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "basal_met", "kcal/day", (FIT_FLOAT64)4, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "physique_rating", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "active_met", "kcal/day", (FIT_FLOAT64)4, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "metabolic_age", "years", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "visceral_fat_rating", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "user_profile_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "bmi", "kg/m^2", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD bloodPressureFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "systolic_pressure", "mmHg", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "diastolic_pressure", "mmHg", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "mean_arterial_pressure", "mmHg", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "map_3_sample_mean", "mmHg", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "map_morning_values", "mmHg", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "map_evening_values", "mmHg", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "heart_rate_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::HrType }, +{ 0, 0, "status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::BpStatus }, +{ 0, 0, "user_profile_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::MessageIndex }, +}; + +static const Profile::FIELD monitoringInfoFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "local_timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::LocalDateTime }, +{ 0, 0, "activity_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 0, false, Profile::Type::ActivityType }, +{ 0, 0, "cycles_to_distance", "m/cycle", (FIT_FLOAT64)5000, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "cycles_to_calories", "kcal/cycle", (FIT_FLOAT64)5000, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "resting_metabolic_rate", "kcal / day", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD_COMPONENT monitoringCurrentActivityTypeIntensityComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 5, 5, FIT_FALSE }, // activity_type + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 28, 3, FIT_FALSE }, // intensity +}; + +static const Profile::SUBFIELD_MAP monitoringCyclesStepsMaps[] = +{ + { 6, 5 }, // activity_type == walking + { 1, 5 }, // activity_type == running +}; + +static const Profile::SUBFIELD_MAP monitoringCyclesStrokesMaps[] = +{ + { 2, 5 }, // activity_type == cycling + { 5, 5 }, // activity_type == swimming +}; + +static const Profile::SUBFIELD monitoringCyclesSubFields[] = +{ + { monitoringCyclesStepsMaps, 0, "steps", "steps", (FIT_FLOAT32)1, (FIT_FLOAT32)0, 2, 0, 134 }, + { monitoringCyclesStrokesMaps, 0, "strokes", "strokes", (FIT_FLOAT32)2, (FIT_FLOAT32)0, 2, 0, 134 }, +}; + +static const Profile::FIELD monitoringFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "device_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::DeviceIndex }, +{ 0, 0, "calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "distance", "m", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, monitoringCyclesSubFields, "cycles", "cycles", (FIT_FLOAT64)2, (FIT_FLOAT64)0, 0, 2, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "active_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "activity_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::ActivityType }, +{ 0, 0, "activity_subtype", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::ActivitySubtype }, +{ 0, 0, "activity_level", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 0, false, Profile::Type::ActivityLevel }, +{ 0, 0, "distance_16", "100 * m", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "cycles_16", "2 * cycles (steps)", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "active_time_16", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "local_timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 134, false, Profile::Type::LocalDateTime }, +{ 0, 0, "temperature", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 12, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "temperature_min", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 14, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "temperature_max", "C", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 15, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "activity_time", "minutes", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 16, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "active_calories", "kcal", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 19, 132, false, Profile::Type::Uint16 }, +{ monitoringCurrentActivityTypeIntensityComponents, 0, "current_activity_type_intensity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 0, 24, 13, false, Profile::Type::Byte }, +{ 0, 0, "timestamp_min_8", "min", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 25, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "timestamp_16", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 26, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 27, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "intensity", "", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 28, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "duration_min", "min", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 29, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "duration", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 30, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "ascent", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 31, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "descent", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 32, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "moderate_activity_minutes", "minutes", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 33, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "vigorous_activity_minutes", "minutes", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 34, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD monitoringHrDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "resting_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "current_day_resting_heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD spo2DataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "reading_spo2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "reading_confidence", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "mode", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::Spo2MeasurementType }, +}; + +static const Profile::FIELD_COMPONENT hrTime256Components[] = +{ + { (FIT_FLOAT64)256, (FIT_FLOAT64)0, 0, 8, FIT_FALSE }, // fractional_timestamp +}; + +static const Profile::FIELD_COMPONENT hrEventTimestamp12Components[] = +{ + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp + { (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 9, 12, FIT_TRUE }, // event_timestamp +}; + +static const Profile::FIELD hrFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "fractional_timestamp", "s", (FIT_FLOAT64)32768, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ hrTime256Components, 0, "time256", "s", (FIT_FLOAT64)256, (FIT_FLOAT64)0, 1, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "filtered_bpm", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "event_timestamp", "s", (FIT_FLOAT64)1024, (FIT_FLOAT64)0, 0, 0, 9, 134, true, Profile::Type::Uint32 }, +{ hrEventTimestamp12Components, 0, "event_timestamp_12", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 10, 0, 10, 13, false, Profile::Type::Byte }, +}; + +static const Profile::FIELD stressLevelFields[] = +{ +{ 0, 0, "stress_level_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "stress_level_time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::DateTime }, +}; + +static const Profile::FIELD maxMetDataFields[] = +{ +{ 0, 0, "update_time", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::DateTime }, +{ 0, 0, "vo2_max", "mL/kg/min", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 0, false, Profile::Type::Sport }, +{ 0, 0, "sub_sport", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::SubSport }, +{ 0, 0, "max_met_category", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::MaxMetCategory }, +{ 0, 0, "calibrated_data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::Bool }, +{ 0, 0, "hr_source", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 12, 0, false, Profile::Type::MaxMetHeartRateSource }, +{ 0, 0, "speed_source", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 13, 0, false, Profile::Type::MaxMetSpeedSource }, +}; + +static const Profile::FIELD hsaBodyBatteryDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "level", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 1, false, Profile::Type::Sint8 }, +{ 0, 0, "charged", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "uncharged", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 131, false, Profile::Type::Sint16 }, +}; + +static const Profile::FIELD hsaEventFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "event_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD hsaAccelerometerDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sampling_interval", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "accel_x", "mG", (FIT_FLOAT64)1.024, (FIT_FLOAT64)0, 0, 0, 2, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "accel_y", "mG", (FIT_FLOAT64)1.024, (FIT_FLOAT64)0, 0, 0, 3, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "accel_z", "mG", (FIT_FLOAT64)1.024, (FIT_FLOAT64)0, 0, 0, 4, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "timestamp_32k", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD hsaGyroscopeDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "sampling_interval", "1/32768 s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "gyro_x", "deg/s", (FIT_FLOAT64)28.57143, (FIT_FLOAT64)0, 0, 0, 2, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "gyro_y", "deg/s", (FIT_FLOAT64)28.57143, (FIT_FLOAT64)0, 0, 0, 3, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "gyro_z", "deg/s", (FIT_FLOAT64)28.57143, (FIT_FLOAT64)0, 0, 0, 4, 131, false, Profile::Type::Sint16 }, +{ 0, 0, "timestamp_32k", "1/32768 s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD hsaStepDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "steps", "steps", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD hsaSpo2DataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "reading_spo2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "confidence", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD hsaStressDataFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "stress_level", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 1, false, Profile::Type::Sint8 }, +}; + +static const Profile::FIELD hsaRespirationDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "respiration_rate", "breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 1, 131, false, Profile::Type::Sint16 }, +}; + +static const Profile::FIELD hsaHeartRateDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "heart_rate", "bpm", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD hsaConfigurationDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 13, false, Profile::Type::Byte }, +{ 0, 0, "data_size", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD hsaWristTemperatureDataFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "processing_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "value", "degC", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD memoGlobFields[] = +{ +{ 0, 0, "part_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 250, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "memo", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 13, false, Profile::Type::Byte }, +{ 0, 0, "mesg_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::MesgNum }, +{ 0, 0, "parent_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "field_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 10, false, Profile::Type::Uint8z }, +}; + +static const Profile::FIELD sleepLevelFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "sleep_level", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SleepLevel }, +}; + +static const Profile::FIELD antChannelIdFields[] = +{ +{ 0, 0, "channel_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "device_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "device_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 139, false, Profile::Type::Uint16z }, +{ 0, 0, "transmission_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 10, false, Profile::Type::Uint8z }, +{ 0, 0, "device_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::DeviceIndex }, +}; + +static const Profile::FIELD_COMPONENT antRxMesgDataComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 8, FIT_FALSE }, // channel_number + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data +}; + +static const Profile::FIELD antRxFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "fractional_timestamp", "s", (FIT_FLOAT64)32768, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "mesg_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 13, false, Profile::Type::Byte }, +{ antRxMesgDataComponents, 0, "mesg_data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 9, 0, 2, 13, false, Profile::Type::Byte }, +{ 0, 0, "channel_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 13, false, Profile::Type::Byte }, +}; + +static const Profile::FIELD_COMPONENT antTxMesgDataComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 8, FIT_FALSE }, // channel_number + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 8, FIT_FALSE }, // data +}; + +static const Profile::FIELD antTxFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "fractional_timestamp", "s", (FIT_FLOAT64)32768, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "mesg_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 13, false, Profile::Type::Byte }, +{ antTxMesgDataComponents, 0, "mesg_data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 9, 0, 2, 13, false, Profile::Type::Byte }, +{ 0, 0, "channel_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 13, false, Profile::Type::Byte }, +}; + +static const Profile::FIELD exdScreenConfigurationFields[] = +{ +{ 0, 0, "screen_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "field_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "layout", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 0, false, Profile::Type::ExdLayout }, +{ 0, 0, "screen_enabled", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 0, false, Profile::Type::Bool }, +}; + +static const Profile::FIELD_COMPONENT exdDataFieldConfigurationConceptFieldComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 4, FIT_FALSE }, // field_id + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 4, FIT_FALSE }, // concept_count +}; + +static const Profile::FIELD exdDataFieldConfigurationFields[] = +{ +{ 0, 0, "screen_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ exdDataFieldConfigurationConceptFieldComponents, 0, "concept_field", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 0, 1, 13, false, Profile::Type::Byte }, +{ 0, 0, "field_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "concept_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "display_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::ExdDisplayType }, +{ 0, 0, "title", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 7, false, Profile::Type::String }, +}; + +static const Profile::FIELD_COMPONENT exdDataConceptConfigurationConceptFieldComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 4, FIT_FALSE }, // field_id + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 4, FIT_FALSE }, // concept_index +}; + +static const Profile::FIELD exdDataConceptConfigurationFields[] = +{ +{ 0, 0, "screen_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ exdDataConceptConfigurationConceptFieldComponents, 0, "concept_field", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 0, 1, 13, false, Profile::Type::Byte }, +{ 0, 0, "field_id", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "concept_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "data_page", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "concept_key", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "scaling", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "data_units", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 0, false, Profile::Type::ExdDataUnits }, +{ 0, 0, "qualifier", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 0, false, Profile::Type::ExdQualifiers }, +{ 0, 0, "descriptor", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 0, false, Profile::Type::ExdDescriptors }, +{ 0, 0, "is_signed", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 0, false, Profile::Type::Bool }, +}; + +static const Profile::FIELD diveSummaryFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "reference_mesg", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::MesgNum }, +{ 0, 0, "reference_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "avg_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_depth", "m", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "surface_interval", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "start_cns", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "end_cns", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "start_n2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "end_n2", "percent", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "o2_toxicity", "OTUs", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "dive_number", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "bottom_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 11, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_pressure_sac", "bar/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 12, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_volume_sac", "L/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 13, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "avg_rmv", "L/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 14, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "descent_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 15, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "ascent_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 16, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_ascent_rate", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 17, 133, false, Profile::Type::Sint32 }, +{ 0, 0, "avg_descent_rate", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 22, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_ascent_rate", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 23, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_descent_rate", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 24, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "hang_time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 25, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD aadAccelFeaturesFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "time", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "energy_total", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "zero_cross_cnt", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "instance", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "time_above_threshold", "s", (FIT_FLOAT64)25, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD hrvFields[] = +{ +{ 0, 0, "time", "s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD beatIntervalsFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "time", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD hrvStatusSummaryFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "weekly_average", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "last_night_average", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "last_night_5_min_high", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "baseline_low_upper", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "baseline_balanced_lower", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 4, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "baseline_balanced_upper", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 5, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "status", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 0, false, Profile::Type::HrvStatus }, +}; + +static const Profile::FIELD hrvValueFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "value", "ms", (FIT_FLOAT64)128, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD_COMPONENT rawBbiDataComponents[] = +{ + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 2, 14, FIT_FALSE }, // time + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 3, 1, FIT_FALSE }, // quality + { (FIT_FLOAT64)1, (FIT_FLOAT64)0, 4, 1, FIT_FALSE }, // gap +}; + +static const Profile::FIELD rawBbiFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "timestamp_ms", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 132, false, Profile::Type::Uint16 }, +{ rawBbiDataComponents, 0, "data", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 45, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "time", "ms", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "quality", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "gap", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +}; + +static const Profile::FIELD respirationRateFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "respiration_rate", "breaths/min", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 0, 131, false, Profile::Type::Sint16 }, +}; + +static const Profile::FIELD chronoShotSessionFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "min_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "max_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 1, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "avg_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 2, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "shot_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "projectile_type", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 0, false, Profile::Type::ProjectileType }, +{ 0, 0, "grain_weight", "gr", (FIT_FLOAT64)10, (FIT_FLOAT64)0, 0, 0, 5, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "standard_deviation", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 6, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD chronoShotDataFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "shot_speed", "m/s", (FIT_FLOAT64)1000, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::Uint32 }, +{ 0, 0, "shot_num", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD tankUpdateFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "sensor", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 140, false, Profile::Type::AntChannelId }, +{ 0, 0, "pressure", "bar", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD tankSummaryFields[] = +{ +{ 0, 0, "timestamp", "s", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "sensor", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 140, false, Profile::Type::AntChannelId }, +{ 0, 0, "start_pressure", "bar", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 1, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "end_pressure", "bar", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 2, 132, false, Profile::Type::Uint16 }, +{ 0, 0, "volume_used", "L", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 3, 134, false, Profile::Type::Uint32 }, +}; + +static const Profile::FIELD sleepAssessmentFields[] = +{ +{ 0, 0, "combined_awake_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "awake_time_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "awakenings_count_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "deep_sleep_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 3, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "sleep_duration_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "light_sleep_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 5, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "overall_sleep_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 6, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "sleep_quality_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 7, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "sleep_recovery_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 8, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "rem_sleep_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 9, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "sleep_restlessness_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 10, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "awakenings_count", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 11, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "interruptions_score", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 14, 2, false, Profile::Type::Uint8 }, +{ 0, 0, "average_stress_during_sleep", "", (FIT_FLOAT64)100, (FIT_FLOAT64)0, 0, 0, 15, 132, false, Profile::Type::Uint16 }, +}; + +static const Profile::FIELD sleepDisruptionSeverityPeriodFields[] = +{ +{ 0, 0, "message_index", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 254, 132, false, Profile::Type::MessageIndex }, +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "severity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SleepDisruptionSeverity }, +}; + +static const Profile::FIELD sleepDisruptionOvernightSeverityFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "severity", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 0, false, Profile::Type::SleepDisruptionSeverity }, +}; + +static const Profile::FIELD skinTempOvernightFields[] = +{ +{ 0, 0, "timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 253, 134, false, Profile::Type::DateTime }, +{ 0, 0, "local_timestamp", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 0, 134, false, Profile::Type::LocalDateTime }, +{ 0, 0, "average_deviation", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 1, 136, false, Profile::Type::Float32 }, +{ 0, 0, "average_7_day_deviation", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 2, 136, false, Profile::Type::Float32 }, +{ 0, 0, "nightly_value", "", (FIT_FLOAT64)1, (FIT_FLOAT64)0, 0, 0, 4, 136, false, Profile::Type::Float32 }, +}; + +const Profile::MESG Profile::mesgs[MESGS] = +{ + { fileIdFields, "file_id", FIT_MESG_NUM_FILE_ID, 7 }, + { fileCreatorFields, "file_creator", FIT_MESG_NUM_FILE_CREATOR, 2 }, + { timestampCorrelationFields, "timestamp_correlation", FIT_MESG_NUM_TIMESTAMP_CORRELATION, 7 }, + { softwareFields, "software", FIT_MESG_NUM_SOFTWARE, 3 }, + { slaveDeviceFields, "slave_device", FIT_MESG_NUM_SLAVE_DEVICE, 2 }, + { capabilitiesFields, "capabilities", FIT_MESG_NUM_CAPABILITIES, 4 }, + { fileCapabilitiesFields, "file_capabilities", FIT_MESG_NUM_FILE_CAPABILITIES, 6 }, + { mesgCapabilitiesFields, "mesg_capabilities", FIT_MESG_NUM_MESG_CAPABILITIES, 5 }, + { fieldCapabilitiesFields, "field_capabilities", FIT_MESG_NUM_FIELD_CAPABILITIES, 5 }, + { deviceSettingsFields, "device_settings", FIT_MESG_NUM_DEVICE_SETTINGS, 24 }, + { userProfileFields, "user_profile", FIT_MESG_NUM_USER_PROFILE, 29 }, + { hrmProfileFields, "hrm_profile", FIT_MESG_NUM_HRM_PROFILE, 5 }, + { sdmProfileFields, "sdm_profile", FIT_MESG_NUM_SDM_PROFILE, 8 }, + { bikeProfileFields, "bike_profile", FIT_MESG_NUM_BIKE_PROFILE, 32 }, + { connectivityFields, "connectivity", FIT_MESG_NUM_CONNECTIVITY, 13 }, + { watchfaceSettingsFields, "watchface_settings", FIT_MESG_NUM_WATCHFACE_SETTINGS, 3 }, + { ohrSettingsFields, "ohr_settings", FIT_MESG_NUM_OHR_SETTINGS, 2 }, + { timeInZoneFields, "time_in_zone", FIT_MESG_NUM_TIME_IN_ZONE, 17 }, + { zonesTargetFields, "zones_target", FIT_MESG_NUM_ZONES_TARGET, 5 }, + { sportFields, "sport", FIT_MESG_NUM_SPORT, 3 }, + { hrZoneFields, "hr_zone", FIT_MESG_NUM_HR_ZONE, 3 }, + { speedZoneFields, "speed_zone", FIT_MESG_NUM_SPEED_ZONE, 3 }, + { cadenceZoneFields, "cadence_zone", FIT_MESG_NUM_CADENCE_ZONE, 3 }, + { powerZoneFields, "power_zone", FIT_MESG_NUM_POWER_ZONE, 3 }, + { metZoneFields, "met_zone", FIT_MESG_NUM_MET_ZONE, 4 }, + { trainingSettingsFields, "training_settings", FIT_MESG_NUM_TRAINING_SETTINGS, 4 }, + { diveSettingsFields, "dive_settings", FIT_MESG_NUM_DIVE_SETTINGS, 35 }, + { diveAlarmFields, "dive_alarm", FIT_MESG_NUM_DIVE_ALARM, 13 }, + { diveApneaAlarmFields, "dive_apnea_alarm", FIT_MESG_NUM_DIVE_APNEA_ALARM, 13 }, + { diveGasFields, "dive_gas", FIT_MESG_NUM_DIVE_GAS, 5 }, + { goalFields, "goal", FIT_MESG_NUM_GOAL, 13 }, + { activityFields, "activity", FIT_MESG_NUM_ACTIVITY, 8 }, + { sessionFields, "session", FIT_MESG_NUM_SESSION, 156 }, + { lapFields, "lap", FIT_MESG_NUM_LAP, 123 }, + { lengthFields, "length", FIT_MESG_NUM_LENGTH, 22 }, + { recordFields, "record", FIT_MESG_NUM_RECORD, 84 }, + { eventFields, "event", FIT_MESG_NUM_EVENT, 19 }, + { deviceInfoFields, "device_info", FIT_MESG_NUM_DEVICE_INFO, 19 }, + { deviceAuxBatteryInfoFields, "device_aux_battery_info", FIT_MESG_NUM_DEVICE_AUX_BATTERY_INFO, 5 }, + { trainingFileFields, "training_file", FIT_MESG_NUM_TRAINING_FILE, 6 }, + { weatherConditionsFields, "weather_conditions", FIT_MESG_NUM_WEATHER_CONDITIONS, 16 }, + { weatherAlertFields, "weather_alert", FIT_MESG_NUM_WEATHER_ALERT, 6 }, + { gpsMetadataFields, "gps_metadata", FIT_MESG_NUM_GPS_METADATA, 9 }, + { cameraEventFields, "camera_event", FIT_MESG_NUM_CAMERA_EVENT, 5 }, + { gyroscopeDataFields, "gyroscope_data", FIT_MESG_NUM_GYROSCOPE_DATA, 9 }, + { accelerometerDataFields, "accelerometer_data", FIT_MESG_NUM_ACCELEROMETER_DATA, 12 }, + { magnetometerDataFields, "magnetometer_data", FIT_MESG_NUM_MAGNETOMETER_DATA, 9 }, + { barometerDataFields, "barometer_data", FIT_MESG_NUM_BAROMETER_DATA, 4 }, + { threeDSensorCalibrationFields, "three_d_sensor_calibration", FIT_MESG_NUM_THREE_D_SENSOR_CALIBRATION, 7 }, + { oneDSensorCalibrationFields, "one_d_sensor_calibration", FIT_MESG_NUM_ONE_D_SENSOR_CALIBRATION, 6 }, + { videoFrameFields, "video_frame", FIT_MESG_NUM_VIDEO_FRAME, 3 }, + { obdiiDataFields, "obdii_data", FIT_MESG_NUM_OBDII_DATA, 9 }, + { nmeaSentenceFields, "nmea_sentence", FIT_MESG_NUM_NMEA_SENTENCE, 3 }, + { aviationAttitudeFields, "aviation_attitude", FIT_MESG_NUM_AVIATION_ATTITUDE, 12 }, + { videoFields, "video", FIT_MESG_NUM_VIDEO, 3 }, + { videoTitleFields, "video_title", FIT_MESG_NUM_VIDEO_TITLE, 3 }, + { videoDescriptionFields, "video_description", FIT_MESG_NUM_VIDEO_DESCRIPTION, 3 }, + { videoClipFields, "video_clip", FIT_MESG_NUM_VIDEO_CLIP, 7 }, + { setFields, "set", FIT_MESG_NUM_SET, 11 }, + { jumpFields, "jump", FIT_MESG_NUM_JUMP, 10 }, + { splitFields, "split", FIT_MESG_NUM_SPLIT, 19 }, + { splitSummaryFields, "split_summary", FIT_MESG_NUM_SPLIT_SUMMARY, 14 }, + { climbProFields, "climb_pro", FIT_MESG_NUM_CLIMB_PRO, 7 }, + { fieldDescriptionFields, "field_description", FIT_MESG_NUM_FIELD_DESCRIPTION, 14 }, + { developerDataIdFields, "developer_data_id", FIT_MESG_NUM_DEVELOPER_DATA_ID, 5 }, + { courseFields, "course", FIT_MESG_NUM_COURSE, 4 }, + { coursePointFields, "course_point", FIT_MESG_NUM_COURSE_POINT, 8 }, + { segmentIdFields, "segment_id", FIT_MESG_NUM_SEGMENT_ID, 9 }, + { segmentLeaderboardEntryFields, "segment_leaderboard_entry", FIT_MESG_NUM_SEGMENT_LEADERBOARD_ENTRY, 7 }, + { segmentPointFields, "segment_point", FIT_MESG_NUM_SEGMENT_POINT, 7 }, + { segmentLapFields, "segment_lap", FIT_MESG_NUM_SEGMENT_LAP, 95 }, + { segmentFileFields, "segment_file", FIT_MESG_NUM_SEGMENT_FILE, 9 }, + { workoutFields, "workout", FIT_MESG_NUM_WORKOUT, 9 }, + { workoutSessionFields, "workout_session", FIT_MESG_NUM_WORKOUT_SESSION, 7 }, + { workoutStepFields, "workout_step", FIT_MESG_NUM_WORKOUT_STEP, 19 }, + { exerciseTitleFields, "exercise_title", FIT_MESG_NUM_EXERCISE_TITLE, 4 }, + { scheduleFields, "schedule", FIT_MESG_NUM_SCHEDULE, 7 }, + { totalsFields, "totals", FIT_MESG_NUM_TOTALS, 10 }, + { weightScaleFields, "weight_scale", FIT_MESG_NUM_WEIGHT_SCALE, 14 }, + { bloodPressureFields, "blood_pressure", FIT_MESG_NUM_BLOOD_PRESSURE, 11 }, + { monitoringInfoFields, "monitoring_info", FIT_MESG_NUM_MONITORING_INFO, 6 }, + { monitoringFields, "monitoring", FIT_MESG_NUM_MONITORING, 29 }, + { monitoringHrDataFields, "monitoring_hr_data", FIT_MESG_NUM_MONITORING_HR_DATA, 3 }, + { spo2DataFields, "spo2_data", FIT_MESG_NUM_SPO2_DATA, 4 }, + { hrFields, "hr", FIT_MESG_NUM_HR, 6 }, + { stressLevelFields, "stress_level", FIT_MESG_NUM_STRESS_LEVEL, 2 }, + { maxMetDataFields, "max_met_data", FIT_MESG_NUM_MAX_MET_DATA, 8 }, + { hsaBodyBatteryDataFields, "hsa_body_battery_data", FIT_MESG_NUM_HSA_BODY_BATTERY_DATA, 5 }, + { hsaEventFields, "hsa_event", FIT_MESG_NUM_HSA_EVENT, 2 }, + { hsaAccelerometerDataFields, "hsa_accelerometer_data", FIT_MESG_NUM_HSA_ACCELEROMETER_DATA, 7 }, + { hsaGyroscopeDataFields, "hsa_gyroscope_data", FIT_MESG_NUM_HSA_GYROSCOPE_DATA, 7 }, + { hsaStepDataFields, "hsa_step_data", FIT_MESG_NUM_HSA_STEP_DATA, 3 }, + { hsaSpo2DataFields, "hsa_spo2_data", FIT_MESG_NUM_HSA_SPO2_DATA, 4 }, + { hsaStressDataFields, "hsa_stress_data", FIT_MESG_NUM_HSA_STRESS_DATA, 3 }, + { hsaRespirationDataFields, "hsa_respiration_data", FIT_MESG_NUM_HSA_RESPIRATION_DATA, 3 }, + { hsaHeartRateDataFields, "hsa_heart_rate_data", FIT_MESG_NUM_HSA_HEART_RATE_DATA, 4 }, + { hsaConfigurationDataFields, "hsa_configuration_data", FIT_MESG_NUM_HSA_CONFIGURATION_DATA, 3 }, + { hsaWristTemperatureDataFields, "hsa_wrist_temperature_data", FIT_MESG_NUM_HSA_WRIST_TEMPERATURE_DATA, 3 }, + { memoGlobFields, "memo_glob", FIT_MESG_NUM_MEMO_GLOB, 6 }, + { sleepLevelFields, "sleep_level", FIT_MESG_NUM_SLEEP_LEVEL, 2 }, + { antChannelIdFields, "ant_channel_id", FIT_MESG_NUM_ANT_CHANNEL_ID, 5 }, + { antRxFields, "ant_rx", FIT_MESG_NUM_ANT_RX, 6 }, + { antTxFields, "ant_tx", FIT_MESG_NUM_ANT_TX, 6 }, + { exdScreenConfigurationFields, "exd_screen_configuration", FIT_MESG_NUM_EXD_SCREEN_CONFIGURATION, 4 }, + { exdDataFieldConfigurationFields, "exd_data_field_configuration", FIT_MESG_NUM_EXD_DATA_FIELD_CONFIGURATION, 6 }, + { exdDataConceptConfigurationFields, "exd_data_concept_configuration", FIT_MESG_NUM_EXD_DATA_CONCEPT_CONFIGURATION, 11 }, + { diveSummaryFields, "dive_summary", FIT_MESG_NUM_DIVE_SUMMARY, 23 }, + { aadAccelFeaturesFields, "aad_accel_features", FIT_MESG_NUM_AAD_ACCEL_FEATURES, 6 }, + { hrvFields, "hrv", FIT_MESG_NUM_HRV, 1 }, + { beatIntervalsFields, "beat_intervals", FIT_MESG_NUM_BEAT_INTERVALS, 3 }, + { hrvStatusSummaryFields, "hrv_status_summary", FIT_MESG_NUM_HRV_STATUS_SUMMARY, 8 }, + { hrvValueFields, "hrv_value", FIT_MESG_NUM_HRV_VALUE, 2 }, + { rawBbiFields, "raw_bbi", FIT_MESG_NUM_RAW_BBI, 6 }, + { respirationRateFields, "respiration_rate", FIT_MESG_NUM_RESPIRATION_RATE, 2 }, + { chronoShotSessionFields, "chrono_shot_session", FIT_MESG_NUM_CHRONO_SHOT_SESSION, 8 }, + { chronoShotDataFields, "chrono_shot_data", FIT_MESG_NUM_CHRONO_SHOT_DATA, 3 }, + { tankUpdateFields, "tank_update", FIT_MESG_NUM_TANK_UPDATE, 3 }, + { tankSummaryFields, "tank_summary", FIT_MESG_NUM_TANK_SUMMARY, 5 }, + { sleepAssessmentFields, "sleep_assessment", FIT_MESG_NUM_SLEEP_ASSESSMENT, 14 }, + { sleepDisruptionSeverityPeriodFields, "sleep_disruption_severity_period", FIT_MESG_NUM_SLEEP_DISRUPTION_SEVERITY_PERIOD, 3 }, + { sleepDisruptionOvernightSeverityFields, "sleep_disruption_overnight_severity", FIT_MESG_NUM_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY, 2 }, + { skinTempOvernightFields, "skin_temp_overnight", FIT_MESG_NUM_SKIN_TEMP_OVERNIGHT, 5 }, + { NULL, "pad", FIT_MESG_NUM_PAD, 0 }, +}; + +const Profile::MESG* Profile::GetMesg(const FIT_UINT16 num) +{ + for (int i = 0; i < MESGS; i++) + { + if (mesgs[i].num == num) + return &mesgs[i]; + } + + return NULL; +} + +const Profile::MESG* Profile::GetMesg(const std::string& name) +{ + for (int i = 0; i < MESGS; i++) + { + if (mesgs[i].name == name) + return &mesgs[i]; + } + + return NULL; +} + +const FIT_UINT16 Profile::GetFieldIndex(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum) +{ + const MESG *mesg = GetMesg(mesgNum); + + if (mesg == NULL) + return FIT_UINT16_INVALID; + + for (FIT_UINT16 i = 0; i < mesg->numFields; i++) + { + if (mesg->fields[i].num == fieldNum) + return i; + } + + return FIT_UINT16_INVALID; +} + +const FIT_UINT16 Profile::GetFieldIndex(const std::string& mesgName, const std::string& fieldName) +{ + const MESG *mesg = GetMesg(mesgName); + + if (mesg == NULL) + return FIT_UINT16_INVALID; + + for (FIT_UINT16 i = 0; i < mesg->numFields; i++) + { + if (mesg->fields[i].name == fieldName) + return i; + + for (FIT_UINT16 j = 0; j < mesg->fields[i].numSubFields; j++) + { + if (mesg->fields[i].subFields[j].name == fieldName) + return i; + } + } + + return FIT_UINT16_INVALID; +} + +const Profile::FIELD* Profile::GetField(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum) +{ + const MESG *mesg = GetMesg(mesgNum); + + if (mesg == NULL) + return NULL; + + FIT_UINT16 fieldIndex = GetFieldIndex(mesgNum, fieldNum); + + if (fieldIndex >= mesg->numFields) + return NULL; + + return &(mesg->fields[fieldIndex]); +} + +const Profile::FIELD* Profile::GetField(const std::string& mesgName, const std::string& fieldName) +{ + const MESG *mesg = GetMesg(mesgName); + + if (mesg == NULL) + return NULL; + + FIT_UINT16 fieldIndex = GetFieldIndex(mesgName, fieldName); + + if (fieldIndex >= mesg->numFields) + return NULL; + + return &(mesg->fields[fieldIndex]); +} + +const FIT_UINT16 Profile::GetSubFieldIndex(const std::string& mesgName, const std::string& fieldName, const std::string& subFieldName) +{ + const FIELD *field = GetField(mesgName, fieldName); + + if (field == NULL) + return FIT_SUBFIELD_INDEX_MAIN_FIELD; + + for (FIT_UINT16 i = 0; i < field->numSubFields; i++) + { + if (field->subFields[i].name == subFieldName) + return i; + } + + return FIT_SUBFIELD_INDEX_MAIN_FIELD; +} + +const Profile::SUBFIELD* Profile::GetSubField(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum, const FIT_UINT16 subFieldIndex) +{ + const MESG *mesg = GetMesg(mesgNum); + + if (mesg == NULL) + return NULL; + + FIT_UINT16 fieldIndex = GetFieldIndex(mesgNum, fieldNum); + + if (fieldIndex >= mesg->numFields) + return NULL; + + if (subFieldIndex >= mesg->fields[fieldIndex].numSubFields) + return NULL; + + return &(mesg->fields[fieldIndex].subFields[subFieldIndex]); +} + +const Profile::SUBFIELD* Profile::GetSubField(const std::string& mesgName, const std::string& fieldName, const std::string& subFieldName) +{ + const MESG *mesg = GetMesg(mesgName); + + if (mesg == NULL) + return NULL; + + FIT_UINT16 fieldIndex = GetFieldIndex(mesgName, fieldName); + + if (fieldIndex >= mesg->numFields) + return NULL; + + FIT_UINT16 subFieldIndex = GetSubFieldIndex(mesgName, fieldName, subFieldName); + + if (subFieldIndex >= mesg->fields[fieldIndex].numSubFields) + return NULL; + + return &(mesg->fields[fieldIndex].subFields[subFieldIndex]); +} + +} // namespace fit + diff --git a/fit_profile.hpp b/fit_profile.hpp new file mode 100644 index 0000000..452cb87 --- /dev/null +++ b/fit_profile.hpp @@ -0,0 +1,7889 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_PROFILE_HPP) +#define FIT_PROFILE_HPP + +#include +#include "fit.hpp" +#include "fit_config.hpp" +#if defined(FIT_CPP_INCLUDE_C) +#include "fit_product.h" +#endif + + +/////////////////////////////////////////////////////////////////////// +// Public Definitions +/////////////////////////////////////////////////////////////////////// + +#if !defined(FIT_CPP_INCLUDE_C) // Types defined in fit_product.h if including C code. + +/////////////////////////////////////////////////////////////////////// +// Types +/////////////////////////////////////////////////////////////////////// + + +typedef FIT_ENUM FIT_FILE; +#define FIT_FILE_INVALID FIT_ENUM_INVALID +#define FIT_FILE_DEVICE ((FIT_FILE)1) // Read only, single file. Must be in root directory. +#define FIT_FILE_SETTINGS ((FIT_FILE)2) // Read/write, single file. Directory=Settings +#define FIT_FILE_SPORT ((FIT_FILE)3) // Read/write, multiple files, file number = sport type. Directory=Sports +#define FIT_FILE_ACTIVITY ((FIT_FILE)4) // Read/erase, multiple files. Directory=Activities +#define FIT_FILE_WORKOUT ((FIT_FILE)5) // Read/write/erase, multiple files. Directory=Workouts +#define FIT_FILE_COURSE ((FIT_FILE)6) // Read/write/erase, multiple files. Directory=Courses +#define FIT_FILE_SCHEDULES ((FIT_FILE)7) // Read/write, single file. Directory=Schedules +#define FIT_FILE_WEIGHT ((FIT_FILE)9) // Read only, single file. Circular buffer. All message definitions at start of file. Directory=Weight +#define FIT_FILE_TOTALS ((FIT_FILE)10) // Read only, single file. Directory=Totals +#define FIT_FILE_GOALS ((FIT_FILE)11) // Read/write, single file. Directory=Goals +#define FIT_FILE_BLOOD_PRESSURE ((FIT_FILE)14) // Read only. Directory=Blood Pressure +#define FIT_FILE_MONITORING_A ((FIT_FILE)15) // Read only. Directory=Monitoring. File number=sub type. +#define FIT_FILE_ACTIVITY_SUMMARY ((FIT_FILE)20) // Read/erase, multiple files. Directory=Activities +#define FIT_FILE_MONITORING_DAILY ((FIT_FILE)28) +#define FIT_FILE_MONITORING_B ((FIT_FILE)32) // Read only. Directory=Monitoring. File number=identifier +#define FIT_FILE_SEGMENT ((FIT_FILE)34) // Read/write/erase. Multiple Files. Directory=Segments +#define FIT_FILE_SEGMENT_LIST ((FIT_FILE)35) // Read/write/erase. Single File. Directory=Segments +#define FIT_FILE_EXD_CONFIGURATION ((FIT_FILE)40) // Read/write/erase. Single File. Directory=Settings +#define FIT_FILE_MFG_RANGE_MIN ((FIT_FILE)0xF7) // 0xF7 - 0xFE reserved for manufacturer specific file types +#define FIT_FILE_MFG_RANGE_MAX ((FIT_FILE)0xFE) // 0xF7 - 0xFE reserved for manufacturer specific file types +#define FIT_FILE_COUNT 20 + +typedef FIT_UINT16 FIT_MESG_NUM; +#define FIT_MESG_NUM_INVALID FIT_UINT16_INVALID +#define FIT_MESG_NUM_FILE_ID ((FIT_MESG_NUM)0) +#define FIT_MESG_NUM_CAPABILITIES ((FIT_MESG_NUM)1) +#define FIT_MESG_NUM_DEVICE_SETTINGS ((FIT_MESG_NUM)2) +#define FIT_MESG_NUM_USER_PROFILE ((FIT_MESG_NUM)3) +#define FIT_MESG_NUM_HRM_PROFILE ((FIT_MESG_NUM)4) +#define FIT_MESG_NUM_SDM_PROFILE ((FIT_MESG_NUM)5) +#define FIT_MESG_NUM_BIKE_PROFILE ((FIT_MESG_NUM)6) +#define FIT_MESG_NUM_ZONES_TARGET ((FIT_MESG_NUM)7) +#define FIT_MESG_NUM_HR_ZONE ((FIT_MESG_NUM)8) +#define FIT_MESG_NUM_POWER_ZONE ((FIT_MESG_NUM)9) +#define FIT_MESG_NUM_MET_ZONE ((FIT_MESG_NUM)10) +#define FIT_MESG_NUM_SPORT ((FIT_MESG_NUM)12) +#define FIT_MESG_NUM_TRAINING_SETTINGS ((FIT_MESG_NUM)13) +#define FIT_MESG_NUM_GOAL ((FIT_MESG_NUM)15) +#define FIT_MESG_NUM_SESSION ((FIT_MESG_NUM)18) +#define FIT_MESG_NUM_LAP ((FIT_MESG_NUM)19) +#define FIT_MESG_NUM_RECORD ((FIT_MESG_NUM)20) +#define FIT_MESG_NUM_EVENT ((FIT_MESG_NUM)21) +#define FIT_MESG_NUM_DEVICE_INFO ((FIT_MESG_NUM)23) +#define FIT_MESG_NUM_WORKOUT ((FIT_MESG_NUM)26) +#define FIT_MESG_NUM_WORKOUT_STEP ((FIT_MESG_NUM)27) +#define FIT_MESG_NUM_SCHEDULE ((FIT_MESG_NUM)28) +#define FIT_MESG_NUM_WEIGHT_SCALE ((FIT_MESG_NUM)30) +#define FIT_MESG_NUM_COURSE ((FIT_MESG_NUM)31) +#define FIT_MESG_NUM_COURSE_POINT ((FIT_MESG_NUM)32) +#define FIT_MESG_NUM_TOTALS ((FIT_MESG_NUM)33) +#define FIT_MESG_NUM_ACTIVITY ((FIT_MESG_NUM)34) +#define FIT_MESG_NUM_SOFTWARE ((FIT_MESG_NUM)35) +#define FIT_MESG_NUM_FILE_CAPABILITIES ((FIT_MESG_NUM)37) +#define FIT_MESG_NUM_MESG_CAPABILITIES ((FIT_MESG_NUM)38) +#define FIT_MESG_NUM_FIELD_CAPABILITIES ((FIT_MESG_NUM)39) +#define FIT_MESG_NUM_FILE_CREATOR ((FIT_MESG_NUM)49) +#define FIT_MESG_NUM_BLOOD_PRESSURE ((FIT_MESG_NUM)51) +#define FIT_MESG_NUM_SPEED_ZONE ((FIT_MESG_NUM)53) +#define FIT_MESG_NUM_MONITORING ((FIT_MESG_NUM)55) +#define FIT_MESG_NUM_TRAINING_FILE ((FIT_MESG_NUM)72) +#define FIT_MESG_NUM_HRV ((FIT_MESG_NUM)78) +#define FIT_MESG_NUM_ANT_RX ((FIT_MESG_NUM)80) +#define FIT_MESG_NUM_ANT_TX ((FIT_MESG_NUM)81) +#define FIT_MESG_NUM_ANT_CHANNEL_ID ((FIT_MESG_NUM)82) +#define FIT_MESG_NUM_LENGTH ((FIT_MESG_NUM)101) +#define FIT_MESG_NUM_MONITORING_INFO ((FIT_MESG_NUM)103) +#define FIT_MESG_NUM_PAD ((FIT_MESG_NUM)105) +#define FIT_MESG_NUM_SLAVE_DEVICE ((FIT_MESG_NUM)106) +#define FIT_MESG_NUM_CONNECTIVITY ((FIT_MESG_NUM)127) +#define FIT_MESG_NUM_WEATHER_CONDITIONS ((FIT_MESG_NUM)128) +#define FIT_MESG_NUM_WEATHER_ALERT ((FIT_MESG_NUM)129) +#define FIT_MESG_NUM_CADENCE_ZONE ((FIT_MESG_NUM)131) +#define FIT_MESG_NUM_HR ((FIT_MESG_NUM)132) +#define FIT_MESG_NUM_SEGMENT_LAP ((FIT_MESG_NUM)142) +#define FIT_MESG_NUM_MEMO_GLOB ((FIT_MESG_NUM)145) +#define FIT_MESG_NUM_SEGMENT_ID ((FIT_MESG_NUM)148) +#define FIT_MESG_NUM_SEGMENT_LEADERBOARD_ENTRY ((FIT_MESG_NUM)149) +#define FIT_MESG_NUM_SEGMENT_POINT ((FIT_MESG_NUM)150) +#define FIT_MESG_NUM_SEGMENT_FILE ((FIT_MESG_NUM)151) +#define FIT_MESG_NUM_WORKOUT_SESSION ((FIT_MESG_NUM)158) +#define FIT_MESG_NUM_WATCHFACE_SETTINGS ((FIT_MESG_NUM)159) +#define FIT_MESG_NUM_GPS_METADATA ((FIT_MESG_NUM)160) +#define FIT_MESG_NUM_CAMERA_EVENT ((FIT_MESG_NUM)161) +#define FIT_MESG_NUM_TIMESTAMP_CORRELATION ((FIT_MESG_NUM)162) +#define FIT_MESG_NUM_GYROSCOPE_DATA ((FIT_MESG_NUM)164) +#define FIT_MESG_NUM_ACCELEROMETER_DATA ((FIT_MESG_NUM)165) +#define FIT_MESG_NUM_THREE_D_SENSOR_CALIBRATION ((FIT_MESG_NUM)167) +#define FIT_MESG_NUM_VIDEO_FRAME ((FIT_MESG_NUM)169) +#define FIT_MESG_NUM_OBDII_DATA ((FIT_MESG_NUM)174) +#define FIT_MESG_NUM_NMEA_SENTENCE ((FIT_MESG_NUM)177) +#define FIT_MESG_NUM_AVIATION_ATTITUDE ((FIT_MESG_NUM)178) +#define FIT_MESG_NUM_VIDEO ((FIT_MESG_NUM)184) +#define FIT_MESG_NUM_VIDEO_TITLE ((FIT_MESG_NUM)185) +#define FIT_MESG_NUM_VIDEO_DESCRIPTION ((FIT_MESG_NUM)186) +#define FIT_MESG_NUM_VIDEO_CLIP ((FIT_MESG_NUM)187) +#define FIT_MESG_NUM_OHR_SETTINGS ((FIT_MESG_NUM)188) +#define FIT_MESG_NUM_EXD_SCREEN_CONFIGURATION ((FIT_MESG_NUM)200) +#define FIT_MESG_NUM_EXD_DATA_FIELD_CONFIGURATION ((FIT_MESG_NUM)201) +#define FIT_MESG_NUM_EXD_DATA_CONCEPT_CONFIGURATION ((FIT_MESG_NUM)202) +#define FIT_MESG_NUM_FIELD_DESCRIPTION ((FIT_MESG_NUM)206) +#define FIT_MESG_NUM_DEVELOPER_DATA_ID ((FIT_MESG_NUM)207) +#define FIT_MESG_NUM_MAGNETOMETER_DATA ((FIT_MESG_NUM)208) +#define FIT_MESG_NUM_BAROMETER_DATA ((FIT_MESG_NUM)209) +#define FIT_MESG_NUM_ONE_D_SENSOR_CALIBRATION ((FIT_MESG_NUM)210) +#define FIT_MESG_NUM_MONITORING_HR_DATA ((FIT_MESG_NUM)211) +#define FIT_MESG_NUM_TIME_IN_ZONE ((FIT_MESG_NUM)216) +#define FIT_MESG_NUM_SET ((FIT_MESG_NUM)225) +#define FIT_MESG_NUM_STRESS_LEVEL ((FIT_MESG_NUM)227) +#define FIT_MESG_NUM_MAX_MET_DATA ((FIT_MESG_NUM)229) +#define FIT_MESG_NUM_DIVE_SETTINGS ((FIT_MESG_NUM)258) +#define FIT_MESG_NUM_DIVE_GAS ((FIT_MESG_NUM)259) +#define FIT_MESG_NUM_DIVE_ALARM ((FIT_MESG_NUM)262) +#define FIT_MESG_NUM_EXERCISE_TITLE ((FIT_MESG_NUM)264) +#define FIT_MESG_NUM_DIVE_SUMMARY ((FIT_MESG_NUM)268) +#define FIT_MESG_NUM_SPO2_DATA ((FIT_MESG_NUM)269) +#define FIT_MESG_NUM_SLEEP_LEVEL ((FIT_MESG_NUM)275) +#define FIT_MESG_NUM_JUMP ((FIT_MESG_NUM)285) +#define FIT_MESG_NUM_AAD_ACCEL_FEATURES ((FIT_MESG_NUM)289) +#define FIT_MESG_NUM_BEAT_INTERVALS ((FIT_MESG_NUM)290) +#define FIT_MESG_NUM_RESPIRATION_RATE ((FIT_MESG_NUM)297) +#define FIT_MESG_NUM_HSA_ACCELEROMETER_DATA ((FIT_MESG_NUM)302) +#define FIT_MESG_NUM_HSA_STEP_DATA ((FIT_MESG_NUM)304) +#define FIT_MESG_NUM_HSA_SPO2_DATA ((FIT_MESG_NUM)305) +#define FIT_MESG_NUM_HSA_STRESS_DATA ((FIT_MESG_NUM)306) +#define FIT_MESG_NUM_HSA_RESPIRATION_DATA ((FIT_MESG_NUM)307) +#define FIT_MESG_NUM_HSA_HEART_RATE_DATA ((FIT_MESG_NUM)308) +#define FIT_MESG_NUM_SPLIT ((FIT_MESG_NUM)312) +#define FIT_MESG_NUM_SPLIT_SUMMARY ((FIT_MESG_NUM)313) +#define FIT_MESG_NUM_HSA_BODY_BATTERY_DATA ((FIT_MESG_NUM)314) +#define FIT_MESG_NUM_HSA_EVENT ((FIT_MESG_NUM)315) +#define FIT_MESG_NUM_CLIMB_PRO ((FIT_MESG_NUM)317) +#define FIT_MESG_NUM_TANK_UPDATE ((FIT_MESG_NUM)319) +#define FIT_MESG_NUM_TANK_SUMMARY ((FIT_MESG_NUM)323) +#define FIT_MESG_NUM_SLEEP_ASSESSMENT ((FIT_MESG_NUM)346) +#define FIT_MESG_NUM_HRV_STATUS_SUMMARY ((FIT_MESG_NUM)370) +#define FIT_MESG_NUM_HRV_VALUE ((FIT_MESG_NUM)371) +#define FIT_MESG_NUM_RAW_BBI ((FIT_MESG_NUM)372) +#define FIT_MESG_NUM_DEVICE_AUX_BATTERY_INFO ((FIT_MESG_NUM)375) +#define FIT_MESG_NUM_HSA_GYROSCOPE_DATA ((FIT_MESG_NUM)376) +#define FIT_MESG_NUM_CHRONO_SHOT_SESSION ((FIT_MESG_NUM)387) +#define FIT_MESG_NUM_CHRONO_SHOT_DATA ((FIT_MESG_NUM)388) +#define FIT_MESG_NUM_HSA_CONFIGURATION_DATA ((FIT_MESG_NUM)389) +#define FIT_MESG_NUM_DIVE_APNEA_ALARM ((FIT_MESG_NUM)393) +#define FIT_MESG_NUM_SKIN_TEMP_OVERNIGHT ((FIT_MESG_NUM)398) +#define FIT_MESG_NUM_HSA_WRIST_TEMPERATURE_DATA ((FIT_MESG_NUM)409) // Message number for the HSA wrist temperature data message +#define FIT_MESG_NUM_SLEEP_DISRUPTION_SEVERITY_PERIOD ((FIT_MESG_NUM)470) +#define FIT_MESG_NUM_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY ((FIT_MESG_NUM)471) +#define FIT_MESG_NUM_MFG_RANGE_MIN ((FIT_MESG_NUM)0xFF00) // 0xFF00 - 0xFFFE reserved for manufacturer specific messages +#define FIT_MESG_NUM_MFG_RANGE_MAX ((FIT_MESG_NUM)0xFFFE) // 0xFF00 - 0xFFFE reserved for manufacturer specific messages +#define FIT_MESG_NUM_COUNT 125 + +typedef FIT_UINT8 FIT_CHECKSUM; +#define FIT_CHECKSUM_INVALID FIT_UINT8_INVALID +#define FIT_CHECKSUM_CLEAR ((FIT_CHECKSUM)0) // Allows clear of checksum for flash memory where can only write 1 to 0 without erasing sector. +#define FIT_CHECKSUM_OK ((FIT_CHECKSUM)1) // Set to mark checksum as valid if computes to invalid values 0 or 0xFF. Checksum can also be set to ok to save encoding computation time. +#define FIT_CHECKSUM_COUNT 2 + +typedef FIT_UINT8Z FIT_FILE_FLAGS; +#define FIT_FILE_FLAGS_INVALID FIT_UINT8Z_INVALID +#define FIT_FILE_FLAGS_READ ((FIT_FILE_FLAGS)0x02) +#define FIT_FILE_FLAGS_WRITE ((FIT_FILE_FLAGS)0x04) +#define FIT_FILE_FLAGS_ERASE ((FIT_FILE_FLAGS)0x08) +#define FIT_FILE_FLAGS_COUNT 3 + +typedef FIT_ENUM FIT_MESG_COUNT; +#define FIT_MESG_COUNT_INVALID FIT_ENUM_INVALID +#define FIT_MESG_COUNT_NUM_PER_FILE ((FIT_MESG_COUNT)0) +#define FIT_MESG_COUNT_MAX_PER_FILE ((FIT_MESG_COUNT)1) +#define FIT_MESG_COUNT_MAX_PER_FILE_TYPE ((FIT_MESG_COUNT)2) +#define FIT_MESG_COUNT_COUNT 3 + +typedef FIT_UINT32 FIT_DATE_TIME; // seconds since UTC 00:00 Dec 31 1989 +#define FIT_DATE_TIME_INVALID FIT_UINT32_INVALID +#define FIT_DATE_TIME_MIN ((FIT_DATE_TIME)0x10000000) // if date_time is < 0x10000000 then it is system time (seconds from device power on) +#define FIT_DATE_TIME_COUNT 1 + +typedef FIT_UINT32 FIT_LOCAL_DATE_TIME; // seconds since 00:00 Dec 31 1989 in local time zone +#define FIT_LOCAL_DATE_TIME_INVALID FIT_UINT32_INVALID +#define FIT_LOCAL_DATE_TIME_MIN ((FIT_LOCAL_DATE_TIME)0x10000000) // if date_time is < 0x10000000 then it is system time (seconds from device power on) +#define FIT_LOCAL_DATE_TIME_COUNT 1 + +typedef FIT_UINT16 FIT_MESSAGE_INDEX; +#define FIT_MESSAGE_INDEX_INVALID FIT_UINT16_INVALID +#define FIT_MESSAGE_INDEX_SELECTED ((FIT_MESSAGE_INDEX)0x8000) // message is selected if set +#define FIT_MESSAGE_INDEX_RESERVED ((FIT_MESSAGE_INDEX)0x7000) // reserved (default 0) +#define FIT_MESSAGE_INDEX_MASK ((FIT_MESSAGE_INDEX)0x0FFF) // index +#define FIT_MESSAGE_INDEX_COUNT 3 + +typedef FIT_UINT8 FIT_DEVICE_INDEX; +#define FIT_DEVICE_INDEX_INVALID FIT_UINT8_INVALID +#define FIT_DEVICE_INDEX_CREATOR ((FIT_DEVICE_INDEX)0) // Creator of the file is always device index 0. +#define FIT_DEVICE_INDEX_COUNT 1 + +typedef FIT_ENUM FIT_GENDER; +#define FIT_GENDER_INVALID FIT_ENUM_INVALID +#define FIT_GENDER_FEMALE ((FIT_GENDER)0) +#define FIT_GENDER_MALE ((FIT_GENDER)1) +#define FIT_GENDER_COUNT 2 + +typedef FIT_ENUM FIT_LANGUAGE; +#define FIT_LANGUAGE_INVALID FIT_ENUM_INVALID +#define FIT_LANGUAGE_ENGLISH ((FIT_LANGUAGE)0) +#define FIT_LANGUAGE_FRENCH ((FIT_LANGUAGE)1) +#define FIT_LANGUAGE_ITALIAN ((FIT_LANGUAGE)2) +#define FIT_LANGUAGE_GERMAN ((FIT_LANGUAGE)3) +#define FIT_LANGUAGE_SPANISH ((FIT_LANGUAGE)4) +#define FIT_LANGUAGE_CROATIAN ((FIT_LANGUAGE)5) +#define FIT_LANGUAGE_CZECH ((FIT_LANGUAGE)6) +#define FIT_LANGUAGE_DANISH ((FIT_LANGUAGE)7) +#define FIT_LANGUAGE_DUTCH ((FIT_LANGUAGE)8) +#define FIT_LANGUAGE_FINNISH ((FIT_LANGUAGE)9) +#define FIT_LANGUAGE_GREEK ((FIT_LANGUAGE)10) +#define FIT_LANGUAGE_HUNGARIAN ((FIT_LANGUAGE)11) +#define FIT_LANGUAGE_NORWEGIAN ((FIT_LANGUAGE)12) +#define FIT_LANGUAGE_POLISH ((FIT_LANGUAGE)13) +#define FIT_LANGUAGE_PORTUGUESE ((FIT_LANGUAGE)14) +#define FIT_LANGUAGE_SLOVAKIAN ((FIT_LANGUAGE)15) +#define FIT_LANGUAGE_SLOVENIAN ((FIT_LANGUAGE)16) +#define FIT_LANGUAGE_SWEDISH ((FIT_LANGUAGE)17) +#define FIT_LANGUAGE_RUSSIAN ((FIT_LANGUAGE)18) +#define FIT_LANGUAGE_TURKISH ((FIT_LANGUAGE)19) +#define FIT_LANGUAGE_LATVIAN ((FIT_LANGUAGE)20) +#define FIT_LANGUAGE_UKRAINIAN ((FIT_LANGUAGE)21) +#define FIT_LANGUAGE_ARABIC ((FIT_LANGUAGE)22) +#define FIT_LANGUAGE_FARSI ((FIT_LANGUAGE)23) +#define FIT_LANGUAGE_BULGARIAN ((FIT_LANGUAGE)24) +#define FIT_LANGUAGE_ROMANIAN ((FIT_LANGUAGE)25) +#define FIT_LANGUAGE_CHINESE ((FIT_LANGUAGE)26) +#define FIT_LANGUAGE_JAPANESE ((FIT_LANGUAGE)27) +#define FIT_LANGUAGE_KOREAN ((FIT_LANGUAGE)28) +#define FIT_LANGUAGE_TAIWANESE ((FIT_LANGUAGE)29) +#define FIT_LANGUAGE_THAI ((FIT_LANGUAGE)30) +#define FIT_LANGUAGE_HEBREW ((FIT_LANGUAGE)31) +#define FIT_LANGUAGE_BRAZILIAN_PORTUGUESE ((FIT_LANGUAGE)32) +#define FIT_LANGUAGE_INDONESIAN ((FIT_LANGUAGE)33) +#define FIT_LANGUAGE_MALAYSIAN ((FIT_LANGUAGE)34) +#define FIT_LANGUAGE_VIETNAMESE ((FIT_LANGUAGE)35) +#define FIT_LANGUAGE_BURMESE ((FIT_LANGUAGE)36) +#define FIT_LANGUAGE_MONGOLIAN ((FIT_LANGUAGE)37) +#define FIT_LANGUAGE_CUSTOM ((FIT_LANGUAGE)254) +#define FIT_LANGUAGE_COUNT 39 + +typedef FIT_UINT8Z FIT_LANGUAGE_BITS_0; // Bit field corresponding to language enum type (1 << language). +#define FIT_LANGUAGE_BITS_0_INVALID FIT_UINT8Z_INVALID +#define FIT_LANGUAGE_BITS_0_ENGLISH ((FIT_LANGUAGE_BITS_0)0x01) +#define FIT_LANGUAGE_BITS_0_FRENCH ((FIT_LANGUAGE_BITS_0)0x02) +#define FIT_LANGUAGE_BITS_0_ITALIAN ((FIT_LANGUAGE_BITS_0)0x04) +#define FIT_LANGUAGE_BITS_0_GERMAN ((FIT_LANGUAGE_BITS_0)0x08) +#define FIT_LANGUAGE_BITS_0_SPANISH ((FIT_LANGUAGE_BITS_0)0x10) +#define FIT_LANGUAGE_BITS_0_CROATIAN ((FIT_LANGUAGE_BITS_0)0x20) +#define FIT_LANGUAGE_BITS_0_CZECH ((FIT_LANGUAGE_BITS_0)0x40) +#define FIT_LANGUAGE_BITS_0_DANISH ((FIT_LANGUAGE_BITS_0)0x80) +#define FIT_LANGUAGE_BITS_0_COUNT 8 + +typedef FIT_UINT8Z FIT_LANGUAGE_BITS_1; +#define FIT_LANGUAGE_BITS_1_INVALID FIT_UINT8Z_INVALID +#define FIT_LANGUAGE_BITS_1_DUTCH ((FIT_LANGUAGE_BITS_1)0x01) +#define FIT_LANGUAGE_BITS_1_FINNISH ((FIT_LANGUAGE_BITS_1)0x02) +#define FIT_LANGUAGE_BITS_1_GREEK ((FIT_LANGUAGE_BITS_1)0x04) +#define FIT_LANGUAGE_BITS_1_HUNGARIAN ((FIT_LANGUAGE_BITS_1)0x08) +#define FIT_LANGUAGE_BITS_1_NORWEGIAN ((FIT_LANGUAGE_BITS_1)0x10) +#define FIT_LANGUAGE_BITS_1_POLISH ((FIT_LANGUAGE_BITS_1)0x20) +#define FIT_LANGUAGE_BITS_1_PORTUGUESE ((FIT_LANGUAGE_BITS_1)0x40) +#define FIT_LANGUAGE_BITS_1_SLOVAKIAN ((FIT_LANGUAGE_BITS_1)0x80) +#define FIT_LANGUAGE_BITS_1_COUNT 8 + +typedef FIT_UINT8Z FIT_LANGUAGE_BITS_2; +#define FIT_LANGUAGE_BITS_2_INVALID FIT_UINT8Z_INVALID +#define FIT_LANGUAGE_BITS_2_SLOVENIAN ((FIT_LANGUAGE_BITS_2)0x01) +#define FIT_LANGUAGE_BITS_2_SWEDISH ((FIT_LANGUAGE_BITS_2)0x02) +#define FIT_LANGUAGE_BITS_2_RUSSIAN ((FIT_LANGUAGE_BITS_2)0x04) +#define FIT_LANGUAGE_BITS_2_TURKISH ((FIT_LANGUAGE_BITS_2)0x08) +#define FIT_LANGUAGE_BITS_2_LATVIAN ((FIT_LANGUAGE_BITS_2)0x10) +#define FIT_LANGUAGE_BITS_2_UKRAINIAN ((FIT_LANGUAGE_BITS_2)0x20) +#define FIT_LANGUAGE_BITS_2_ARABIC ((FIT_LANGUAGE_BITS_2)0x40) +#define FIT_LANGUAGE_BITS_2_FARSI ((FIT_LANGUAGE_BITS_2)0x80) +#define FIT_LANGUAGE_BITS_2_COUNT 8 + +typedef FIT_UINT8Z FIT_LANGUAGE_BITS_3; +#define FIT_LANGUAGE_BITS_3_INVALID FIT_UINT8Z_INVALID +#define FIT_LANGUAGE_BITS_3_BULGARIAN ((FIT_LANGUAGE_BITS_3)0x01) +#define FIT_LANGUAGE_BITS_3_ROMANIAN ((FIT_LANGUAGE_BITS_3)0x02) +#define FIT_LANGUAGE_BITS_3_CHINESE ((FIT_LANGUAGE_BITS_3)0x04) +#define FIT_LANGUAGE_BITS_3_JAPANESE ((FIT_LANGUAGE_BITS_3)0x08) +#define FIT_LANGUAGE_BITS_3_KOREAN ((FIT_LANGUAGE_BITS_3)0x10) +#define FIT_LANGUAGE_BITS_3_TAIWANESE ((FIT_LANGUAGE_BITS_3)0x20) +#define FIT_LANGUAGE_BITS_3_THAI ((FIT_LANGUAGE_BITS_3)0x40) +#define FIT_LANGUAGE_BITS_3_HEBREW ((FIT_LANGUAGE_BITS_3)0x80) +#define FIT_LANGUAGE_BITS_3_COUNT 8 + +typedef FIT_UINT8Z FIT_LANGUAGE_BITS_4; +#define FIT_LANGUAGE_BITS_4_INVALID FIT_UINT8Z_INVALID +#define FIT_LANGUAGE_BITS_4_BRAZILIAN_PORTUGUESE ((FIT_LANGUAGE_BITS_4)0x01) +#define FIT_LANGUAGE_BITS_4_INDONESIAN ((FIT_LANGUAGE_BITS_4)0x02) +#define FIT_LANGUAGE_BITS_4_MALAYSIAN ((FIT_LANGUAGE_BITS_4)0x04) +#define FIT_LANGUAGE_BITS_4_VIETNAMESE ((FIT_LANGUAGE_BITS_4)0x08) +#define FIT_LANGUAGE_BITS_4_BURMESE ((FIT_LANGUAGE_BITS_4)0x10) +#define FIT_LANGUAGE_BITS_4_MONGOLIAN ((FIT_LANGUAGE_BITS_4)0x20) +#define FIT_LANGUAGE_BITS_4_COUNT 6 + +typedef FIT_ENUM FIT_TIME_ZONE; +#define FIT_TIME_ZONE_INVALID FIT_ENUM_INVALID +#define FIT_TIME_ZONE_ALMATY ((FIT_TIME_ZONE)0) +#define FIT_TIME_ZONE_BANGKOK ((FIT_TIME_ZONE)1) +#define FIT_TIME_ZONE_BOMBAY ((FIT_TIME_ZONE)2) +#define FIT_TIME_ZONE_BRASILIA ((FIT_TIME_ZONE)3) +#define FIT_TIME_ZONE_CAIRO ((FIT_TIME_ZONE)4) +#define FIT_TIME_ZONE_CAPE_VERDE_IS ((FIT_TIME_ZONE)5) +#define FIT_TIME_ZONE_DARWIN ((FIT_TIME_ZONE)6) +#define FIT_TIME_ZONE_ENIWETOK ((FIT_TIME_ZONE)7) +#define FIT_TIME_ZONE_FIJI ((FIT_TIME_ZONE)8) +#define FIT_TIME_ZONE_HONG_KONG ((FIT_TIME_ZONE)9) +#define FIT_TIME_ZONE_ISLAMABAD ((FIT_TIME_ZONE)10) +#define FIT_TIME_ZONE_KABUL ((FIT_TIME_ZONE)11) +#define FIT_TIME_ZONE_MAGADAN ((FIT_TIME_ZONE)12) +#define FIT_TIME_ZONE_MID_ATLANTIC ((FIT_TIME_ZONE)13) +#define FIT_TIME_ZONE_MOSCOW ((FIT_TIME_ZONE)14) +#define FIT_TIME_ZONE_MUSCAT ((FIT_TIME_ZONE)15) +#define FIT_TIME_ZONE_NEWFOUNDLAND ((FIT_TIME_ZONE)16) +#define FIT_TIME_ZONE_SAMOA ((FIT_TIME_ZONE)17) +#define FIT_TIME_ZONE_SYDNEY ((FIT_TIME_ZONE)18) +#define FIT_TIME_ZONE_TEHRAN ((FIT_TIME_ZONE)19) +#define FIT_TIME_ZONE_TOKYO ((FIT_TIME_ZONE)20) +#define FIT_TIME_ZONE_US_ALASKA ((FIT_TIME_ZONE)21) +#define FIT_TIME_ZONE_US_ATLANTIC ((FIT_TIME_ZONE)22) +#define FIT_TIME_ZONE_US_CENTRAL ((FIT_TIME_ZONE)23) +#define FIT_TIME_ZONE_US_EASTERN ((FIT_TIME_ZONE)24) +#define FIT_TIME_ZONE_US_HAWAII ((FIT_TIME_ZONE)25) +#define FIT_TIME_ZONE_US_MOUNTAIN ((FIT_TIME_ZONE)26) +#define FIT_TIME_ZONE_US_PACIFIC ((FIT_TIME_ZONE)27) +#define FIT_TIME_ZONE_OTHER ((FIT_TIME_ZONE)28) +#define FIT_TIME_ZONE_AUCKLAND ((FIT_TIME_ZONE)29) +#define FIT_TIME_ZONE_KATHMANDU ((FIT_TIME_ZONE)30) +#define FIT_TIME_ZONE_EUROPE_WESTERN_WET ((FIT_TIME_ZONE)31) +#define FIT_TIME_ZONE_EUROPE_CENTRAL_CET ((FIT_TIME_ZONE)32) +#define FIT_TIME_ZONE_EUROPE_EASTERN_EET ((FIT_TIME_ZONE)33) +#define FIT_TIME_ZONE_JAKARTA ((FIT_TIME_ZONE)34) +#define FIT_TIME_ZONE_PERTH ((FIT_TIME_ZONE)35) +#define FIT_TIME_ZONE_ADELAIDE ((FIT_TIME_ZONE)36) +#define FIT_TIME_ZONE_BRISBANE ((FIT_TIME_ZONE)37) +#define FIT_TIME_ZONE_TASMANIA ((FIT_TIME_ZONE)38) +#define FIT_TIME_ZONE_ICELAND ((FIT_TIME_ZONE)39) +#define FIT_TIME_ZONE_AMSTERDAM ((FIT_TIME_ZONE)40) +#define FIT_TIME_ZONE_ATHENS ((FIT_TIME_ZONE)41) +#define FIT_TIME_ZONE_BARCELONA ((FIT_TIME_ZONE)42) +#define FIT_TIME_ZONE_BERLIN ((FIT_TIME_ZONE)43) +#define FIT_TIME_ZONE_BRUSSELS ((FIT_TIME_ZONE)44) +#define FIT_TIME_ZONE_BUDAPEST ((FIT_TIME_ZONE)45) +#define FIT_TIME_ZONE_COPENHAGEN ((FIT_TIME_ZONE)46) +#define FIT_TIME_ZONE_DUBLIN ((FIT_TIME_ZONE)47) +#define FIT_TIME_ZONE_HELSINKI ((FIT_TIME_ZONE)48) +#define FIT_TIME_ZONE_LISBON ((FIT_TIME_ZONE)49) +#define FIT_TIME_ZONE_LONDON ((FIT_TIME_ZONE)50) +#define FIT_TIME_ZONE_MADRID ((FIT_TIME_ZONE)51) +#define FIT_TIME_ZONE_MUNICH ((FIT_TIME_ZONE)52) +#define FIT_TIME_ZONE_OSLO ((FIT_TIME_ZONE)53) +#define FIT_TIME_ZONE_PARIS ((FIT_TIME_ZONE)54) +#define FIT_TIME_ZONE_PRAGUE ((FIT_TIME_ZONE)55) +#define FIT_TIME_ZONE_REYKJAVIK ((FIT_TIME_ZONE)56) +#define FIT_TIME_ZONE_ROME ((FIT_TIME_ZONE)57) +#define FIT_TIME_ZONE_STOCKHOLM ((FIT_TIME_ZONE)58) +#define FIT_TIME_ZONE_VIENNA ((FIT_TIME_ZONE)59) +#define FIT_TIME_ZONE_WARSAW ((FIT_TIME_ZONE)60) +#define FIT_TIME_ZONE_ZURICH ((FIT_TIME_ZONE)61) +#define FIT_TIME_ZONE_QUEBEC ((FIT_TIME_ZONE)62) +#define FIT_TIME_ZONE_ONTARIO ((FIT_TIME_ZONE)63) +#define FIT_TIME_ZONE_MANITOBA ((FIT_TIME_ZONE)64) +#define FIT_TIME_ZONE_SASKATCHEWAN ((FIT_TIME_ZONE)65) +#define FIT_TIME_ZONE_ALBERTA ((FIT_TIME_ZONE)66) +#define FIT_TIME_ZONE_BRITISH_COLUMBIA ((FIT_TIME_ZONE)67) +#define FIT_TIME_ZONE_BOISE ((FIT_TIME_ZONE)68) +#define FIT_TIME_ZONE_BOSTON ((FIT_TIME_ZONE)69) +#define FIT_TIME_ZONE_CHICAGO ((FIT_TIME_ZONE)70) +#define FIT_TIME_ZONE_DALLAS ((FIT_TIME_ZONE)71) +#define FIT_TIME_ZONE_DENVER ((FIT_TIME_ZONE)72) +#define FIT_TIME_ZONE_KANSAS_CITY ((FIT_TIME_ZONE)73) +#define FIT_TIME_ZONE_LAS_VEGAS ((FIT_TIME_ZONE)74) +#define FIT_TIME_ZONE_LOS_ANGELES ((FIT_TIME_ZONE)75) +#define FIT_TIME_ZONE_MIAMI ((FIT_TIME_ZONE)76) +#define FIT_TIME_ZONE_MINNEAPOLIS ((FIT_TIME_ZONE)77) +#define FIT_TIME_ZONE_NEW_YORK ((FIT_TIME_ZONE)78) +#define FIT_TIME_ZONE_NEW_ORLEANS ((FIT_TIME_ZONE)79) +#define FIT_TIME_ZONE_PHOENIX ((FIT_TIME_ZONE)80) +#define FIT_TIME_ZONE_SANTA_FE ((FIT_TIME_ZONE)81) +#define FIT_TIME_ZONE_SEATTLE ((FIT_TIME_ZONE)82) +#define FIT_TIME_ZONE_WASHINGTON_DC ((FIT_TIME_ZONE)83) +#define FIT_TIME_ZONE_US_ARIZONA ((FIT_TIME_ZONE)84) +#define FIT_TIME_ZONE_CHITA ((FIT_TIME_ZONE)85) +#define FIT_TIME_ZONE_EKATERINBURG ((FIT_TIME_ZONE)86) +#define FIT_TIME_ZONE_IRKUTSK ((FIT_TIME_ZONE)87) +#define FIT_TIME_ZONE_KALININGRAD ((FIT_TIME_ZONE)88) +#define FIT_TIME_ZONE_KRASNOYARSK ((FIT_TIME_ZONE)89) +#define FIT_TIME_ZONE_NOVOSIBIRSK ((FIT_TIME_ZONE)90) +#define FIT_TIME_ZONE_PETROPAVLOVSK_KAMCHATSKIY ((FIT_TIME_ZONE)91) +#define FIT_TIME_ZONE_SAMARA ((FIT_TIME_ZONE)92) +#define FIT_TIME_ZONE_VLADIVOSTOK ((FIT_TIME_ZONE)93) +#define FIT_TIME_ZONE_MEXICO_CENTRAL ((FIT_TIME_ZONE)94) +#define FIT_TIME_ZONE_MEXICO_MOUNTAIN ((FIT_TIME_ZONE)95) +#define FIT_TIME_ZONE_MEXICO_PACIFIC ((FIT_TIME_ZONE)96) +#define FIT_TIME_ZONE_CAPE_TOWN ((FIT_TIME_ZONE)97) +#define FIT_TIME_ZONE_WINKHOEK ((FIT_TIME_ZONE)98) +#define FIT_TIME_ZONE_LAGOS ((FIT_TIME_ZONE)99) +#define FIT_TIME_ZONE_RIYAHD ((FIT_TIME_ZONE)100) +#define FIT_TIME_ZONE_VENEZUELA ((FIT_TIME_ZONE)101) +#define FIT_TIME_ZONE_AUSTRALIA_LH ((FIT_TIME_ZONE)102) +#define FIT_TIME_ZONE_SANTIAGO ((FIT_TIME_ZONE)103) +#define FIT_TIME_ZONE_MANUAL ((FIT_TIME_ZONE)253) +#define FIT_TIME_ZONE_AUTOMATIC ((FIT_TIME_ZONE)254) +#define FIT_TIME_ZONE_COUNT 106 + +typedef FIT_ENUM FIT_DISPLAY_MEASURE; +#define FIT_DISPLAY_MEASURE_INVALID FIT_ENUM_INVALID +#define FIT_DISPLAY_MEASURE_METRIC ((FIT_DISPLAY_MEASURE)0) +#define FIT_DISPLAY_MEASURE_STATUTE ((FIT_DISPLAY_MEASURE)1) +#define FIT_DISPLAY_MEASURE_NAUTICAL ((FIT_DISPLAY_MEASURE)2) +#define FIT_DISPLAY_MEASURE_COUNT 3 + +typedef FIT_ENUM FIT_DISPLAY_HEART; +#define FIT_DISPLAY_HEART_INVALID FIT_ENUM_INVALID +#define FIT_DISPLAY_HEART_BPM ((FIT_DISPLAY_HEART)0) +#define FIT_DISPLAY_HEART_MAX ((FIT_DISPLAY_HEART)1) +#define FIT_DISPLAY_HEART_RESERVE ((FIT_DISPLAY_HEART)2) +#define FIT_DISPLAY_HEART_COUNT 3 + +typedef FIT_ENUM FIT_DISPLAY_POWER; +#define FIT_DISPLAY_POWER_INVALID FIT_ENUM_INVALID +#define FIT_DISPLAY_POWER_WATTS ((FIT_DISPLAY_POWER)0) +#define FIT_DISPLAY_POWER_PERCENT_FTP ((FIT_DISPLAY_POWER)1) +#define FIT_DISPLAY_POWER_COUNT 2 + +typedef FIT_ENUM FIT_DISPLAY_POSITION; +#define FIT_DISPLAY_POSITION_INVALID FIT_ENUM_INVALID +#define FIT_DISPLAY_POSITION_DEGREE ((FIT_DISPLAY_POSITION)0) // dd.dddddd +#define FIT_DISPLAY_POSITION_DEGREE_MINUTE ((FIT_DISPLAY_POSITION)1) // dddmm.mmm +#define FIT_DISPLAY_POSITION_DEGREE_MINUTE_SECOND ((FIT_DISPLAY_POSITION)2) // dddmmss +#define FIT_DISPLAY_POSITION_AUSTRIAN_GRID ((FIT_DISPLAY_POSITION)3) // Austrian Grid (BMN) +#define FIT_DISPLAY_POSITION_BRITISH_GRID ((FIT_DISPLAY_POSITION)4) // British National Grid +#define FIT_DISPLAY_POSITION_DUTCH_GRID ((FIT_DISPLAY_POSITION)5) // Dutch grid system +#define FIT_DISPLAY_POSITION_HUNGARIAN_GRID ((FIT_DISPLAY_POSITION)6) // Hungarian grid system +#define FIT_DISPLAY_POSITION_FINNISH_GRID ((FIT_DISPLAY_POSITION)7) // Finnish grid system Zone3 KKJ27 +#define FIT_DISPLAY_POSITION_GERMAN_GRID ((FIT_DISPLAY_POSITION)8) // Gausss Krueger (German) +#define FIT_DISPLAY_POSITION_ICELANDIC_GRID ((FIT_DISPLAY_POSITION)9) // Icelandic Grid +#define FIT_DISPLAY_POSITION_INDONESIAN_EQUATORIAL ((FIT_DISPLAY_POSITION)10) // Indonesian Equatorial LCO +#define FIT_DISPLAY_POSITION_INDONESIAN_IRIAN ((FIT_DISPLAY_POSITION)11) // Indonesian Irian LCO +#define FIT_DISPLAY_POSITION_INDONESIAN_SOUTHERN ((FIT_DISPLAY_POSITION)12) // Indonesian Southern LCO +#define FIT_DISPLAY_POSITION_INDIA_ZONE_0 ((FIT_DISPLAY_POSITION)13) // India zone 0 +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IA ((FIT_DISPLAY_POSITION)14) // India zone IA +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IB ((FIT_DISPLAY_POSITION)15) // India zone IB +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IIA ((FIT_DISPLAY_POSITION)16) // India zone IIA +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IIB ((FIT_DISPLAY_POSITION)17) // India zone IIB +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IIIA ((FIT_DISPLAY_POSITION)18) // India zone IIIA +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IIIB ((FIT_DISPLAY_POSITION)19) // India zone IIIB +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IVA ((FIT_DISPLAY_POSITION)20) // India zone IVA +#define FIT_DISPLAY_POSITION_INDIA_ZONE_IVB ((FIT_DISPLAY_POSITION)21) // India zone IVB +#define FIT_DISPLAY_POSITION_IRISH_TRANSVERSE ((FIT_DISPLAY_POSITION)22) // Irish Transverse Mercator +#define FIT_DISPLAY_POSITION_IRISH_GRID ((FIT_DISPLAY_POSITION)23) // Irish Grid +#define FIT_DISPLAY_POSITION_LORAN ((FIT_DISPLAY_POSITION)24) // Loran TD +#define FIT_DISPLAY_POSITION_MAIDENHEAD_GRID ((FIT_DISPLAY_POSITION)25) // Maidenhead grid system +#define FIT_DISPLAY_POSITION_MGRS_GRID ((FIT_DISPLAY_POSITION)26) // MGRS grid system +#define FIT_DISPLAY_POSITION_NEW_ZEALAND_GRID ((FIT_DISPLAY_POSITION)27) // New Zealand grid system +#define FIT_DISPLAY_POSITION_NEW_ZEALAND_TRANSVERSE ((FIT_DISPLAY_POSITION)28) // New Zealand Transverse Mercator +#define FIT_DISPLAY_POSITION_QATAR_GRID ((FIT_DISPLAY_POSITION)29) // Qatar National Grid +#define FIT_DISPLAY_POSITION_MODIFIED_SWEDISH_GRID ((FIT_DISPLAY_POSITION)30) // Modified RT-90 (Sweden) +#define FIT_DISPLAY_POSITION_SWEDISH_GRID ((FIT_DISPLAY_POSITION)31) // RT-90 (Sweden) +#define FIT_DISPLAY_POSITION_SOUTH_AFRICAN_GRID ((FIT_DISPLAY_POSITION)32) // South African Grid +#define FIT_DISPLAY_POSITION_SWISS_GRID ((FIT_DISPLAY_POSITION)33) // Swiss CH-1903 grid +#define FIT_DISPLAY_POSITION_TAIWAN_GRID ((FIT_DISPLAY_POSITION)34) // Taiwan Grid +#define FIT_DISPLAY_POSITION_UNITED_STATES_GRID ((FIT_DISPLAY_POSITION)35) // United States National Grid +#define FIT_DISPLAY_POSITION_UTM_UPS_GRID ((FIT_DISPLAY_POSITION)36) // UTM/UPS grid system +#define FIT_DISPLAY_POSITION_WEST_MALAYAN ((FIT_DISPLAY_POSITION)37) // West Malayan RSO +#define FIT_DISPLAY_POSITION_BORNEO_RSO ((FIT_DISPLAY_POSITION)38) // Borneo RSO +#define FIT_DISPLAY_POSITION_ESTONIAN_GRID ((FIT_DISPLAY_POSITION)39) // Estonian grid system +#define FIT_DISPLAY_POSITION_LATVIAN_GRID ((FIT_DISPLAY_POSITION)40) // Latvian Transverse Mercator +#define FIT_DISPLAY_POSITION_SWEDISH_REF_99_GRID ((FIT_DISPLAY_POSITION)41) // Reference Grid 99 TM (Swedish) +#define FIT_DISPLAY_POSITION_COUNT 42 + +typedef FIT_ENUM FIT_SWITCH; +#define FIT_SWITCH_INVALID FIT_ENUM_INVALID +#define FIT_SWITCH_OFF ((FIT_SWITCH)0) +#define FIT_SWITCH_ON ((FIT_SWITCH)1) +#define FIT_SWITCH_AUTO ((FIT_SWITCH)2) +#define FIT_SWITCH_COUNT 3 + +typedef FIT_ENUM FIT_SPORT; +#define FIT_SPORT_INVALID FIT_ENUM_INVALID +#define FIT_SPORT_GENERIC ((FIT_SPORT)0) +#define FIT_SPORT_RUNNING ((FIT_SPORT)1) +#define FIT_SPORT_CYCLING ((FIT_SPORT)2) +#define FIT_SPORT_TRANSITION ((FIT_SPORT)3) // Mulitsport transition +#define FIT_SPORT_FITNESS_EQUIPMENT ((FIT_SPORT)4) +#define FIT_SPORT_SWIMMING ((FIT_SPORT)5) +#define FIT_SPORT_BASKETBALL ((FIT_SPORT)6) +#define FIT_SPORT_SOCCER ((FIT_SPORT)7) +#define FIT_SPORT_TENNIS ((FIT_SPORT)8) +#define FIT_SPORT_AMERICAN_FOOTBALL ((FIT_SPORT)9) +#define FIT_SPORT_TRAINING ((FIT_SPORT)10) +#define FIT_SPORT_WALKING ((FIT_SPORT)11) +#define FIT_SPORT_CROSS_COUNTRY_SKIING ((FIT_SPORT)12) +#define FIT_SPORT_ALPINE_SKIING ((FIT_SPORT)13) +#define FIT_SPORT_SNOWBOARDING ((FIT_SPORT)14) +#define FIT_SPORT_ROWING ((FIT_SPORT)15) +#define FIT_SPORT_MOUNTAINEERING ((FIT_SPORT)16) +#define FIT_SPORT_HIKING ((FIT_SPORT)17) +#define FIT_SPORT_MULTISPORT ((FIT_SPORT)18) +#define FIT_SPORT_PADDLING ((FIT_SPORT)19) +#define FIT_SPORT_FLYING ((FIT_SPORT)20) +#define FIT_SPORT_E_BIKING ((FIT_SPORT)21) +#define FIT_SPORT_MOTORCYCLING ((FIT_SPORT)22) +#define FIT_SPORT_BOATING ((FIT_SPORT)23) +#define FIT_SPORT_DRIVING ((FIT_SPORT)24) +#define FIT_SPORT_GOLF ((FIT_SPORT)25) +#define FIT_SPORT_HANG_GLIDING ((FIT_SPORT)26) +#define FIT_SPORT_HORSEBACK_RIDING ((FIT_SPORT)27) +#define FIT_SPORT_HUNTING ((FIT_SPORT)28) +#define FIT_SPORT_FISHING ((FIT_SPORT)29) +#define FIT_SPORT_INLINE_SKATING ((FIT_SPORT)30) +#define FIT_SPORT_ROCK_CLIMBING ((FIT_SPORT)31) +#define FIT_SPORT_SAILING ((FIT_SPORT)32) +#define FIT_SPORT_ICE_SKATING ((FIT_SPORT)33) +#define FIT_SPORT_SKY_DIVING ((FIT_SPORT)34) +#define FIT_SPORT_SNOWSHOEING ((FIT_SPORT)35) +#define FIT_SPORT_SNOWMOBILING ((FIT_SPORT)36) +#define FIT_SPORT_STAND_UP_PADDLEBOARDING ((FIT_SPORT)37) +#define FIT_SPORT_SURFING ((FIT_SPORT)38) +#define FIT_SPORT_WAKEBOARDING ((FIT_SPORT)39) +#define FIT_SPORT_WATER_SKIING ((FIT_SPORT)40) +#define FIT_SPORT_KAYAKING ((FIT_SPORT)41) +#define FIT_SPORT_RAFTING ((FIT_SPORT)42) +#define FIT_SPORT_WINDSURFING ((FIT_SPORT)43) +#define FIT_SPORT_KITESURFING ((FIT_SPORT)44) +#define FIT_SPORT_TACTICAL ((FIT_SPORT)45) +#define FIT_SPORT_JUMPMASTER ((FIT_SPORT)46) +#define FIT_SPORT_BOXING ((FIT_SPORT)47) +#define FIT_SPORT_FLOOR_CLIMBING ((FIT_SPORT)48) +#define FIT_SPORT_BASEBALL ((FIT_SPORT)49) +#define FIT_SPORT_DIVING ((FIT_SPORT)53) +#define FIT_SPORT_HIIT ((FIT_SPORT)62) +#define FIT_SPORT_RACKET ((FIT_SPORT)64) +#define FIT_SPORT_WHEELCHAIR_PUSH_WALK ((FIT_SPORT)65) +#define FIT_SPORT_WHEELCHAIR_PUSH_RUN ((FIT_SPORT)66) +#define FIT_SPORT_MEDITATION ((FIT_SPORT)67) +#define FIT_SPORT_DISC_GOLF ((FIT_SPORT)69) +#define FIT_SPORT_CRICKET ((FIT_SPORT)71) +#define FIT_SPORT_RUGBY ((FIT_SPORT)72) +#define FIT_SPORT_HOCKEY ((FIT_SPORT)73) +#define FIT_SPORT_LACROSSE ((FIT_SPORT)74) +#define FIT_SPORT_VOLLEYBALL ((FIT_SPORT)75) +#define FIT_SPORT_WATER_TUBING ((FIT_SPORT)76) +#define FIT_SPORT_WAKESURFING ((FIT_SPORT)77) +#define FIT_SPORT_MIXED_MARTIAL_ARTS ((FIT_SPORT)80) +#define FIT_SPORT_SNORKELING ((FIT_SPORT)82) +#define FIT_SPORT_DANCE ((FIT_SPORT)83) +#define FIT_SPORT_JUMP_ROPE ((FIT_SPORT)84) +#define FIT_SPORT_ALL ((FIT_SPORT)254) // All is for goals only to include all sports. +#define FIT_SPORT_COUNT 69 + +typedef FIT_UINT8Z FIT_SPORT_BITS_0; // Bit field corresponding to sport enum type (1 << sport). +#define FIT_SPORT_BITS_0_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_0_GENERIC ((FIT_SPORT_BITS_0)0x01) +#define FIT_SPORT_BITS_0_RUNNING ((FIT_SPORT_BITS_0)0x02) +#define FIT_SPORT_BITS_0_CYCLING ((FIT_SPORT_BITS_0)0x04) +#define FIT_SPORT_BITS_0_TRANSITION ((FIT_SPORT_BITS_0)0x08) // Mulitsport transition +#define FIT_SPORT_BITS_0_FITNESS_EQUIPMENT ((FIT_SPORT_BITS_0)0x10) +#define FIT_SPORT_BITS_0_SWIMMING ((FIT_SPORT_BITS_0)0x20) +#define FIT_SPORT_BITS_0_BASKETBALL ((FIT_SPORT_BITS_0)0x40) +#define FIT_SPORT_BITS_0_SOCCER ((FIT_SPORT_BITS_0)0x80) +#define FIT_SPORT_BITS_0_COUNT 8 + +typedef FIT_UINT8Z FIT_SPORT_BITS_1; // Bit field corresponding to sport enum type (1 << (sport-8)). +#define FIT_SPORT_BITS_1_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_1_TENNIS ((FIT_SPORT_BITS_1)0x01) +#define FIT_SPORT_BITS_1_AMERICAN_FOOTBALL ((FIT_SPORT_BITS_1)0x02) +#define FIT_SPORT_BITS_1_TRAINING ((FIT_SPORT_BITS_1)0x04) +#define FIT_SPORT_BITS_1_WALKING ((FIT_SPORT_BITS_1)0x08) +#define FIT_SPORT_BITS_1_CROSS_COUNTRY_SKIING ((FIT_SPORT_BITS_1)0x10) +#define FIT_SPORT_BITS_1_ALPINE_SKIING ((FIT_SPORT_BITS_1)0x20) +#define FIT_SPORT_BITS_1_SNOWBOARDING ((FIT_SPORT_BITS_1)0x40) +#define FIT_SPORT_BITS_1_ROWING ((FIT_SPORT_BITS_1)0x80) +#define FIT_SPORT_BITS_1_COUNT 8 + +typedef FIT_UINT8Z FIT_SPORT_BITS_2; // Bit field corresponding to sport enum type (1 << (sport-16)). +#define FIT_SPORT_BITS_2_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_2_MOUNTAINEERING ((FIT_SPORT_BITS_2)0x01) +#define FIT_SPORT_BITS_2_HIKING ((FIT_SPORT_BITS_2)0x02) +#define FIT_SPORT_BITS_2_MULTISPORT ((FIT_SPORT_BITS_2)0x04) +#define FIT_SPORT_BITS_2_PADDLING ((FIT_SPORT_BITS_2)0x08) +#define FIT_SPORT_BITS_2_FLYING ((FIT_SPORT_BITS_2)0x10) +#define FIT_SPORT_BITS_2_E_BIKING ((FIT_SPORT_BITS_2)0x20) +#define FIT_SPORT_BITS_2_MOTORCYCLING ((FIT_SPORT_BITS_2)0x40) +#define FIT_SPORT_BITS_2_BOATING ((FIT_SPORT_BITS_2)0x80) +#define FIT_SPORT_BITS_2_COUNT 8 + +typedef FIT_UINT8Z FIT_SPORT_BITS_3; // Bit field corresponding to sport enum type (1 << (sport-24)). +#define FIT_SPORT_BITS_3_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_3_DRIVING ((FIT_SPORT_BITS_3)0x01) +#define FIT_SPORT_BITS_3_GOLF ((FIT_SPORT_BITS_3)0x02) +#define FIT_SPORT_BITS_3_HANG_GLIDING ((FIT_SPORT_BITS_3)0x04) +#define FIT_SPORT_BITS_3_HORSEBACK_RIDING ((FIT_SPORT_BITS_3)0x08) +#define FIT_SPORT_BITS_3_HUNTING ((FIT_SPORT_BITS_3)0x10) +#define FIT_SPORT_BITS_3_FISHING ((FIT_SPORT_BITS_3)0x20) +#define FIT_SPORT_BITS_3_INLINE_SKATING ((FIT_SPORT_BITS_3)0x40) +#define FIT_SPORT_BITS_3_ROCK_CLIMBING ((FIT_SPORT_BITS_3)0x80) +#define FIT_SPORT_BITS_3_COUNT 8 + +typedef FIT_UINT8Z FIT_SPORT_BITS_4; // Bit field corresponding to sport enum type (1 << (sport-32)). +#define FIT_SPORT_BITS_4_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_4_SAILING ((FIT_SPORT_BITS_4)0x01) +#define FIT_SPORT_BITS_4_ICE_SKATING ((FIT_SPORT_BITS_4)0x02) +#define FIT_SPORT_BITS_4_SKY_DIVING ((FIT_SPORT_BITS_4)0x04) +#define FIT_SPORT_BITS_4_SNOWSHOEING ((FIT_SPORT_BITS_4)0x08) +#define FIT_SPORT_BITS_4_SNOWMOBILING ((FIT_SPORT_BITS_4)0x10) +#define FIT_SPORT_BITS_4_STAND_UP_PADDLEBOARDING ((FIT_SPORT_BITS_4)0x20) +#define FIT_SPORT_BITS_4_SURFING ((FIT_SPORT_BITS_4)0x40) +#define FIT_SPORT_BITS_4_WAKEBOARDING ((FIT_SPORT_BITS_4)0x80) +#define FIT_SPORT_BITS_4_COUNT 8 + +typedef FIT_UINT8Z FIT_SPORT_BITS_5; // Bit field corresponding to sport enum type (1 << (sport-40)). +#define FIT_SPORT_BITS_5_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_5_WATER_SKIING ((FIT_SPORT_BITS_5)0x01) +#define FIT_SPORT_BITS_5_KAYAKING ((FIT_SPORT_BITS_5)0x02) +#define FIT_SPORT_BITS_5_RAFTING ((FIT_SPORT_BITS_5)0x04) +#define FIT_SPORT_BITS_5_WINDSURFING ((FIT_SPORT_BITS_5)0x08) +#define FIT_SPORT_BITS_5_KITESURFING ((FIT_SPORT_BITS_5)0x10) +#define FIT_SPORT_BITS_5_TACTICAL ((FIT_SPORT_BITS_5)0x20) +#define FIT_SPORT_BITS_5_JUMPMASTER ((FIT_SPORT_BITS_5)0x40) +#define FIT_SPORT_BITS_5_BOXING ((FIT_SPORT_BITS_5)0x80) +#define FIT_SPORT_BITS_5_COUNT 8 + +typedef FIT_UINT8Z FIT_SPORT_BITS_6; // Bit field corresponding to sport enum type (1 << (sport-48)). +#define FIT_SPORT_BITS_6_INVALID FIT_UINT8Z_INVALID +#define FIT_SPORT_BITS_6_FLOOR_CLIMBING ((FIT_SPORT_BITS_6)0x01) +#define FIT_SPORT_BITS_6_COUNT 1 + +typedef FIT_ENUM FIT_SUB_SPORT; +#define FIT_SUB_SPORT_INVALID FIT_ENUM_INVALID +#define FIT_SUB_SPORT_GENERIC ((FIT_SUB_SPORT)0) +#define FIT_SUB_SPORT_TREADMILL ((FIT_SUB_SPORT)1) // Run/Fitness Equipment +#define FIT_SUB_SPORT_STREET ((FIT_SUB_SPORT)2) // Run +#define FIT_SUB_SPORT_TRAIL ((FIT_SUB_SPORT)3) // Run +#define FIT_SUB_SPORT_TRACK ((FIT_SUB_SPORT)4) // Run +#define FIT_SUB_SPORT_SPIN ((FIT_SUB_SPORT)5) // Cycling +#define FIT_SUB_SPORT_INDOOR_CYCLING ((FIT_SUB_SPORT)6) // Cycling/Fitness Equipment +#define FIT_SUB_SPORT_ROAD ((FIT_SUB_SPORT)7) // Cycling +#define FIT_SUB_SPORT_MOUNTAIN ((FIT_SUB_SPORT)8) // Cycling +#define FIT_SUB_SPORT_DOWNHILL ((FIT_SUB_SPORT)9) // Cycling +#define FIT_SUB_SPORT_RECUMBENT ((FIT_SUB_SPORT)10) // Cycling +#define FIT_SUB_SPORT_CYCLOCROSS ((FIT_SUB_SPORT)11) // Cycling +#define FIT_SUB_SPORT_HAND_CYCLING ((FIT_SUB_SPORT)12) // Cycling +#define FIT_SUB_SPORT_TRACK_CYCLING ((FIT_SUB_SPORT)13) // Cycling +#define FIT_SUB_SPORT_INDOOR_ROWING ((FIT_SUB_SPORT)14) // Fitness Equipment +#define FIT_SUB_SPORT_ELLIPTICAL ((FIT_SUB_SPORT)15) // Fitness Equipment +#define FIT_SUB_SPORT_STAIR_CLIMBING ((FIT_SUB_SPORT)16) // Fitness Equipment +#define FIT_SUB_SPORT_LAP_SWIMMING ((FIT_SUB_SPORT)17) // Swimming +#define FIT_SUB_SPORT_OPEN_WATER ((FIT_SUB_SPORT)18) // Swimming +#define FIT_SUB_SPORT_FLEXIBILITY_TRAINING ((FIT_SUB_SPORT)19) // Training +#define FIT_SUB_SPORT_STRENGTH_TRAINING ((FIT_SUB_SPORT)20) // Training +#define FIT_SUB_SPORT_WARM_UP ((FIT_SUB_SPORT)21) // Tennis +#define FIT_SUB_SPORT_MATCH ((FIT_SUB_SPORT)22) // Tennis +#define FIT_SUB_SPORT_EXERCISE ((FIT_SUB_SPORT)23) // Tennis +#define FIT_SUB_SPORT_CHALLENGE ((FIT_SUB_SPORT)24) +#define FIT_SUB_SPORT_INDOOR_SKIING ((FIT_SUB_SPORT)25) // Fitness Equipment +#define FIT_SUB_SPORT_CARDIO_TRAINING ((FIT_SUB_SPORT)26) // Training +#define FIT_SUB_SPORT_INDOOR_WALKING ((FIT_SUB_SPORT)27) // Walking/Fitness Equipment +#define FIT_SUB_SPORT_E_BIKE_FITNESS ((FIT_SUB_SPORT)28) // E-Biking +#define FIT_SUB_SPORT_BMX ((FIT_SUB_SPORT)29) // Cycling +#define FIT_SUB_SPORT_CASUAL_WALKING ((FIT_SUB_SPORT)30) // Walking +#define FIT_SUB_SPORT_SPEED_WALKING ((FIT_SUB_SPORT)31) // Walking +#define FIT_SUB_SPORT_BIKE_TO_RUN_TRANSITION ((FIT_SUB_SPORT)32) // Transition +#define FIT_SUB_SPORT_RUN_TO_BIKE_TRANSITION ((FIT_SUB_SPORT)33) // Transition +#define FIT_SUB_SPORT_SWIM_TO_BIKE_TRANSITION ((FIT_SUB_SPORT)34) // Transition +#define FIT_SUB_SPORT_ATV ((FIT_SUB_SPORT)35) // Motorcycling +#define FIT_SUB_SPORT_MOTOCROSS ((FIT_SUB_SPORT)36) // Motorcycling +#define FIT_SUB_SPORT_BACKCOUNTRY ((FIT_SUB_SPORT)37) // Alpine Skiing/Snowboarding +#define FIT_SUB_SPORT_RESORT ((FIT_SUB_SPORT)38) // Alpine Skiing/Snowboarding +#define FIT_SUB_SPORT_RC_DRONE ((FIT_SUB_SPORT)39) // Flying +#define FIT_SUB_SPORT_WINGSUIT ((FIT_SUB_SPORT)40) // Flying +#define FIT_SUB_SPORT_WHITEWATER ((FIT_SUB_SPORT)41) // Kayaking/Rafting +#define FIT_SUB_SPORT_SKATE_SKIING ((FIT_SUB_SPORT)42) // Cross Country Skiing +#define FIT_SUB_SPORT_YOGA ((FIT_SUB_SPORT)43) // Training +#define FIT_SUB_SPORT_PILATES ((FIT_SUB_SPORT)44) // Fitness Equipment +#define FIT_SUB_SPORT_INDOOR_RUNNING ((FIT_SUB_SPORT)45) // Run +#define FIT_SUB_SPORT_GRAVEL_CYCLING ((FIT_SUB_SPORT)46) // Cycling +#define FIT_SUB_SPORT_E_BIKE_MOUNTAIN ((FIT_SUB_SPORT)47) // Cycling +#define FIT_SUB_SPORT_COMMUTING ((FIT_SUB_SPORT)48) // Cycling +#define FIT_SUB_SPORT_MIXED_SURFACE ((FIT_SUB_SPORT)49) // Cycling +#define FIT_SUB_SPORT_NAVIGATE ((FIT_SUB_SPORT)50) +#define FIT_SUB_SPORT_TRACK_ME ((FIT_SUB_SPORT)51) +#define FIT_SUB_SPORT_MAP ((FIT_SUB_SPORT)52) +#define FIT_SUB_SPORT_SINGLE_GAS_DIVING ((FIT_SUB_SPORT)53) // Diving +#define FIT_SUB_SPORT_MULTI_GAS_DIVING ((FIT_SUB_SPORT)54) // Diving +#define FIT_SUB_SPORT_GAUGE_DIVING ((FIT_SUB_SPORT)55) // Diving +#define FIT_SUB_SPORT_APNEA_DIVING ((FIT_SUB_SPORT)56) // Diving +#define FIT_SUB_SPORT_APNEA_HUNTING ((FIT_SUB_SPORT)57) // Diving +#define FIT_SUB_SPORT_VIRTUAL_ACTIVITY ((FIT_SUB_SPORT)58) +#define FIT_SUB_SPORT_OBSTACLE ((FIT_SUB_SPORT)59) // Used for events where participants run, crawl through mud, climb over walls, etc. +#define FIT_SUB_SPORT_BREATHING ((FIT_SUB_SPORT)62) +#define FIT_SUB_SPORT_SAIL_RACE ((FIT_SUB_SPORT)65) // Sailing +#define FIT_SUB_SPORT_ULTRA ((FIT_SUB_SPORT)67) // Ultramarathon +#define FIT_SUB_SPORT_INDOOR_CLIMBING ((FIT_SUB_SPORT)68) // Climbing +#define FIT_SUB_SPORT_BOULDERING ((FIT_SUB_SPORT)69) // Climbing +#define FIT_SUB_SPORT_HIIT ((FIT_SUB_SPORT)70) // High Intensity Interval Training +#define FIT_SUB_SPORT_AMRAP ((FIT_SUB_SPORT)73) // HIIT +#define FIT_SUB_SPORT_EMOM ((FIT_SUB_SPORT)74) // HIIT +#define FIT_SUB_SPORT_TABATA ((FIT_SUB_SPORT)75) // HIIT +#define FIT_SUB_SPORT_PICKLEBALL ((FIT_SUB_SPORT)84) // Racket +#define FIT_SUB_SPORT_PADEL ((FIT_SUB_SPORT)85) // Racket +#define FIT_SUB_SPORT_INDOOR_WHEELCHAIR_WALK ((FIT_SUB_SPORT)86) +#define FIT_SUB_SPORT_INDOOR_WHEELCHAIR_RUN ((FIT_SUB_SPORT)87) +#define FIT_SUB_SPORT_INDOOR_HAND_CYCLING ((FIT_SUB_SPORT)88) +#define FIT_SUB_SPORT_SQUASH ((FIT_SUB_SPORT)94) +#define FIT_SUB_SPORT_BADMINTON ((FIT_SUB_SPORT)95) +#define FIT_SUB_SPORT_RACQUETBALL ((FIT_SUB_SPORT)96) +#define FIT_SUB_SPORT_TABLE_TENNIS ((FIT_SUB_SPORT)97) +#define FIT_SUB_SPORT_FLY_CANOPY ((FIT_SUB_SPORT)110) // Flying +#define FIT_SUB_SPORT_FLY_PARAGLIDE ((FIT_SUB_SPORT)111) // Flying +#define FIT_SUB_SPORT_FLY_PARAMOTOR ((FIT_SUB_SPORT)112) // Flying +#define FIT_SUB_SPORT_FLY_PRESSURIZED ((FIT_SUB_SPORT)113) // Flying +#define FIT_SUB_SPORT_FLY_NAVIGATE ((FIT_SUB_SPORT)114) // Flying +#define FIT_SUB_SPORT_FLY_TIMER ((FIT_SUB_SPORT)115) // Flying +#define FIT_SUB_SPORT_FLY_ALTIMETER ((FIT_SUB_SPORT)116) // Flying +#define FIT_SUB_SPORT_FLY_WX ((FIT_SUB_SPORT)117) // Flying +#define FIT_SUB_SPORT_FLY_VFR ((FIT_SUB_SPORT)118) // Flying +#define FIT_SUB_SPORT_FLY_IFR ((FIT_SUB_SPORT)119) // Flying +#define FIT_SUB_SPORT_ALL ((FIT_SUB_SPORT)254) +#define FIT_SUB_SPORT_COUNT 89 + +typedef FIT_ENUM FIT_SPORT_EVENT; +#define FIT_SPORT_EVENT_INVALID FIT_ENUM_INVALID +#define FIT_SPORT_EVENT_UNCATEGORIZED ((FIT_SPORT_EVENT)0) +#define FIT_SPORT_EVENT_GEOCACHING ((FIT_SPORT_EVENT)1) +#define FIT_SPORT_EVENT_FITNESS ((FIT_SPORT_EVENT)2) +#define FIT_SPORT_EVENT_RECREATION ((FIT_SPORT_EVENT)3) +#define FIT_SPORT_EVENT_RACE ((FIT_SPORT_EVENT)4) +#define FIT_SPORT_EVENT_SPECIAL_EVENT ((FIT_SPORT_EVENT)5) +#define FIT_SPORT_EVENT_TRAINING ((FIT_SPORT_EVENT)6) +#define FIT_SPORT_EVENT_TRANSPORTATION ((FIT_SPORT_EVENT)7) +#define FIT_SPORT_EVENT_TOURING ((FIT_SPORT_EVENT)8) +#define FIT_SPORT_EVENT_COUNT 9 + +typedef FIT_ENUM FIT_ACTIVITY; +#define FIT_ACTIVITY_INVALID FIT_ENUM_INVALID +#define FIT_ACTIVITY_MANUAL ((FIT_ACTIVITY)0) +#define FIT_ACTIVITY_AUTO_MULTI_SPORT ((FIT_ACTIVITY)1) +#define FIT_ACTIVITY_COUNT 2 + +typedef FIT_ENUM FIT_INTENSITY; +#define FIT_INTENSITY_INVALID FIT_ENUM_INVALID +#define FIT_INTENSITY_ACTIVE ((FIT_INTENSITY)0) +#define FIT_INTENSITY_REST ((FIT_INTENSITY)1) +#define FIT_INTENSITY_WARMUP ((FIT_INTENSITY)2) +#define FIT_INTENSITY_COOLDOWN ((FIT_INTENSITY)3) +#define FIT_INTENSITY_RECOVERY ((FIT_INTENSITY)4) +#define FIT_INTENSITY_INTERVAL ((FIT_INTENSITY)5) +#define FIT_INTENSITY_OTHER ((FIT_INTENSITY)6) +#define FIT_INTENSITY_COUNT 7 + +typedef FIT_ENUM FIT_SESSION_TRIGGER; +#define FIT_SESSION_TRIGGER_INVALID FIT_ENUM_INVALID +#define FIT_SESSION_TRIGGER_ACTIVITY_END ((FIT_SESSION_TRIGGER)0) +#define FIT_SESSION_TRIGGER_MANUAL ((FIT_SESSION_TRIGGER)1) // User changed sport. +#define FIT_SESSION_TRIGGER_AUTO_MULTI_SPORT ((FIT_SESSION_TRIGGER)2) // Auto multi-sport feature is enabled and user pressed lap button to advance session. +#define FIT_SESSION_TRIGGER_FITNESS_EQUIPMENT ((FIT_SESSION_TRIGGER)3) // Auto sport change caused by user linking to fitness equipment. +#define FIT_SESSION_TRIGGER_COUNT 4 + +typedef FIT_ENUM FIT_AUTOLAP_TRIGGER; +#define FIT_AUTOLAP_TRIGGER_INVALID FIT_ENUM_INVALID +#define FIT_AUTOLAP_TRIGGER_TIME ((FIT_AUTOLAP_TRIGGER)0) +#define FIT_AUTOLAP_TRIGGER_DISTANCE ((FIT_AUTOLAP_TRIGGER)1) +#define FIT_AUTOLAP_TRIGGER_POSITION_START ((FIT_AUTOLAP_TRIGGER)2) +#define FIT_AUTOLAP_TRIGGER_POSITION_LAP ((FIT_AUTOLAP_TRIGGER)3) +#define FIT_AUTOLAP_TRIGGER_POSITION_WAYPOINT ((FIT_AUTOLAP_TRIGGER)4) +#define FIT_AUTOLAP_TRIGGER_POSITION_MARKED ((FIT_AUTOLAP_TRIGGER)5) +#define FIT_AUTOLAP_TRIGGER_OFF ((FIT_AUTOLAP_TRIGGER)6) +#define FIT_AUTOLAP_TRIGGER_AUTO_SELECT ((FIT_AUTOLAP_TRIGGER)13) +#define FIT_AUTOLAP_TRIGGER_COUNT 8 + +typedef FIT_ENUM FIT_LAP_TRIGGER; +#define FIT_LAP_TRIGGER_INVALID FIT_ENUM_INVALID +#define FIT_LAP_TRIGGER_MANUAL ((FIT_LAP_TRIGGER)0) +#define FIT_LAP_TRIGGER_TIME ((FIT_LAP_TRIGGER)1) +#define FIT_LAP_TRIGGER_DISTANCE ((FIT_LAP_TRIGGER)2) +#define FIT_LAP_TRIGGER_POSITION_START ((FIT_LAP_TRIGGER)3) +#define FIT_LAP_TRIGGER_POSITION_LAP ((FIT_LAP_TRIGGER)4) +#define FIT_LAP_TRIGGER_POSITION_WAYPOINT ((FIT_LAP_TRIGGER)5) +#define FIT_LAP_TRIGGER_POSITION_MARKED ((FIT_LAP_TRIGGER)6) +#define FIT_LAP_TRIGGER_SESSION_END ((FIT_LAP_TRIGGER)7) +#define FIT_LAP_TRIGGER_FITNESS_EQUIPMENT ((FIT_LAP_TRIGGER)8) +#define FIT_LAP_TRIGGER_COUNT 9 + +typedef FIT_ENUM FIT_TIME_MODE; +#define FIT_TIME_MODE_INVALID FIT_ENUM_INVALID +#define FIT_TIME_MODE_HOUR12 ((FIT_TIME_MODE)0) +#define FIT_TIME_MODE_HOUR24 ((FIT_TIME_MODE)1) // Does not use a leading zero and has a colon +#define FIT_TIME_MODE_MILITARY ((FIT_TIME_MODE)2) // Uses a leading zero and does not have a colon +#define FIT_TIME_MODE_HOUR_12_WITH_SECONDS ((FIT_TIME_MODE)3) +#define FIT_TIME_MODE_HOUR_24_WITH_SECONDS ((FIT_TIME_MODE)4) +#define FIT_TIME_MODE_UTC ((FIT_TIME_MODE)5) +#define FIT_TIME_MODE_COUNT 6 + +typedef FIT_ENUM FIT_BACKLIGHT_MODE; +#define FIT_BACKLIGHT_MODE_INVALID FIT_ENUM_INVALID +#define FIT_BACKLIGHT_MODE_OFF ((FIT_BACKLIGHT_MODE)0) +#define FIT_BACKLIGHT_MODE_MANUAL ((FIT_BACKLIGHT_MODE)1) +#define FIT_BACKLIGHT_MODE_KEY_AND_MESSAGES ((FIT_BACKLIGHT_MODE)2) +#define FIT_BACKLIGHT_MODE_AUTO_BRIGHTNESS ((FIT_BACKLIGHT_MODE)3) +#define FIT_BACKLIGHT_MODE_SMART_NOTIFICATIONS ((FIT_BACKLIGHT_MODE)4) +#define FIT_BACKLIGHT_MODE_KEY_AND_MESSAGES_NIGHT ((FIT_BACKLIGHT_MODE)5) +#define FIT_BACKLIGHT_MODE_KEY_AND_MESSAGES_AND_SMART_NOTIFICATIONS ((FIT_BACKLIGHT_MODE)6) +#define FIT_BACKLIGHT_MODE_COUNT 7 + +typedef FIT_ENUM FIT_DATE_MODE; +#define FIT_DATE_MODE_INVALID FIT_ENUM_INVALID +#define FIT_DATE_MODE_DAY_MONTH ((FIT_DATE_MODE)0) +#define FIT_DATE_MODE_MONTH_DAY ((FIT_DATE_MODE)1) +#define FIT_DATE_MODE_COUNT 2 + +typedef FIT_UINT8 FIT_BACKLIGHT_TIMEOUT; // Timeout in seconds. +#define FIT_BACKLIGHT_TIMEOUT_INVALID FIT_UINT8_INVALID +#define FIT_BACKLIGHT_TIMEOUT_INFINITE ((FIT_BACKLIGHT_TIMEOUT)0) // Backlight stays on forever. +#define FIT_BACKLIGHT_TIMEOUT_COUNT 1 + +typedef FIT_ENUM FIT_EVENT; +#define FIT_EVENT_INVALID FIT_ENUM_INVALID +#define FIT_EVENT_TIMER ((FIT_EVENT)0) // Group 0. Start / stop_all +#define FIT_EVENT_WORKOUT ((FIT_EVENT)3) // start / stop +#define FIT_EVENT_WORKOUT_STEP ((FIT_EVENT)4) // Start at beginning of workout. Stop at end of each step. +#define FIT_EVENT_POWER_DOWN ((FIT_EVENT)5) // stop_all group 0 +#define FIT_EVENT_POWER_UP ((FIT_EVENT)6) // stop_all group 0 +#define FIT_EVENT_OFF_COURSE ((FIT_EVENT)7) // start / stop group 0 +#define FIT_EVENT_SESSION ((FIT_EVENT)8) // Stop at end of each session. +#define FIT_EVENT_LAP ((FIT_EVENT)9) // Stop at end of each lap. +#define FIT_EVENT_COURSE_POINT ((FIT_EVENT)10) // marker +#define FIT_EVENT_BATTERY ((FIT_EVENT)11) // marker +#define FIT_EVENT_VIRTUAL_PARTNER_PACE ((FIT_EVENT)12) // Group 1. Start at beginning of activity if VP enabled, when VP pace is changed during activity or VP enabled mid activity. stop_disable when VP disabled. +#define FIT_EVENT_HR_HIGH_ALERT ((FIT_EVENT)13) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_HR_LOW_ALERT ((FIT_EVENT)14) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_SPEED_HIGH_ALERT ((FIT_EVENT)15) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_SPEED_LOW_ALERT ((FIT_EVENT)16) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_CAD_HIGH_ALERT ((FIT_EVENT)17) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_CAD_LOW_ALERT ((FIT_EVENT)18) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_POWER_HIGH_ALERT ((FIT_EVENT)19) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_POWER_LOW_ALERT ((FIT_EVENT)20) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_RECOVERY_HR ((FIT_EVENT)21) // marker +#define FIT_EVENT_BATTERY_LOW ((FIT_EVENT)22) // marker +#define FIT_EVENT_TIME_DURATION_ALERT ((FIT_EVENT)23) // Group 1. Start if enabled mid activity (not required at start of activity). Stop when duration is reached. stop_disable if disabled. +#define FIT_EVENT_DISTANCE_DURATION_ALERT ((FIT_EVENT)24) // Group 1. Start if enabled mid activity (not required at start of activity). Stop when duration is reached. stop_disable if disabled. +#define FIT_EVENT_CALORIE_DURATION_ALERT ((FIT_EVENT)25) // Group 1. Start if enabled mid activity (not required at start of activity). Stop when duration is reached. stop_disable if disabled. +#define FIT_EVENT_ACTIVITY ((FIT_EVENT)26) // Group 1.. Stop at end of activity. +#define FIT_EVENT_FITNESS_EQUIPMENT ((FIT_EVENT)27) // marker +#define FIT_EVENT_LENGTH ((FIT_EVENT)28) // Stop at end of each length. +#define FIT_EVENT_USER_MARKER ((FIT_EVENT)32) // marker +#define FIT_EVENT_SPORT_POINT ((FIT_EVENT)33) // marker +#define FIT_EVENT_CALIBRATION ((FIT_EVENT)36) // start/stop/marker +#define FIT_EVENT_FRONT_GEAR_CHANGE ((FIT_EVENT)42) // marker +#define FIT_EVENT_REAR_GEAR_CHANGE ((FIT_EVENT)43) // marker +#define FIT_EVENT_RIDER_POSITION_CHANGE ((FIT_EVENT)44) // marker +#define FIT_EVENT_ELEV_HIGH_ALERT ((FIT_EVENT)45) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_ELEV_LOW_ALERT ((FIT_EVENT)46) // Group 0. Start / stop when in alert condition. +#define FIT_EVENT_COMM_TIMEOUT ((FIT_EVENT)47) // marker +#define FIT_EVENT_AUTO_ACTIVITY_DETECT ((FIT_EVENT)54) // marker +#define FIT_EVENT_DIVE_ALERT ((FIT_EVENT)56) // marker +#define FIT_EVENT_DIVE_GAS_SWITCHED ((FIT_EVENT)57) // marker +#define FIT_EVENT_TANK_PRESSURE_RESERVE ((FIT_EVENT)71) // marker +#define FIT_EVENT_TANK_PRESSURE_CRITICAL ((FIT_EVENT)72) // marker +#define FIT_EVENT_TANK_LOST ((FIT_EVENT)73) // marker +#define FIT_EVENT_RADAR_THREAT_ALERT ((FIT_EVENT)75) // start/stop/marker +#define FIT_EVENT_TANK_BATTERY_LOW ((FIT_EVENT)76) // marker +#define FIT_EVENT_TANK_POD_CONNECTED ((FIT_EVENT)81) // marker - tank pod has connected +#define FIT_EVENT_TANK_POD_DISCONNECTED ((FIT_EVENT)82) // marker - tank pod has lost connection +#define FIT_EVENT_COUNT 46 + +typedef FIT_ENUM FIT_EVENT_TYPE; +#define FIT_EVENT_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_EVENT_TYPE_START ((FIT_EVENT_TYPE)0) +#define FIT_EVENT_TYPE_STOP ((FIT_EVENT_TYPE)1) +#define FIT_EVENT_TYPE_CONSECUTIVE_DEPRECIATED ((FIT_EVENT_TYPE)2) +#define FIT_EVENT_TYPE_MARKER ((FIT_EVENT_TYPE)3) +#define FIT_EVENT_TYPE_STOP_ALL ((FIT_EVENT_TYPE)4) +#define FIT_EVENT_TYPE_BEGIN_DEPRECIATED ((FIT_EVENT_TYPE)5) +#define FIT_EVENT_TYPE_END_DEPRECIATED ((FIT_EVENT_TYPE)6) +#define FIT_EVENT_TYPE_END_ALL_DEPRECIATED ((FIT_EVENT_TYPE)7) +#define FIT_EVENT_TYPE_STOP_DISABLE ((FIT_EVENT_TYPE)8) +#define FIT_EVENT_TYPE_STOP_DISABLE_ALL ((FIT_EVENT_TYPE)9) +#define FIT_EVENT_TYPE_COUNT 10 + +typedef FIT_ENUM FIT_TIMER_TRIGGER; // timer event data +#define FIT_TIMER_TRIGGER_INVALID FIT_ENUM_INVALID +#define FIT_TIMER_TRIGGER_MANUAL ((FIT_TIMER_TRIGGER)0) +#define FIT_TIMER_TRIGGER_AUTO ((FIT_TIMER_TRIGGER)1) +#define FIT_TIMER_TRIGGER_FITNESS_EQUIPMENT ((FIT_TIMER_TRIGGER)2) +#define FIT_TIMER_TRIGGER_COUNT 3 + +typedef FIT_ENUM FIT_FITNESS_EQUIPMENT_STATE; // fitness equipment event data +#define FIT_FITNESS_EQUIPMENT_STATE_INVALID FIT_ENUM_INVALID +#define FIT_FITNESS_EQUIPMENT_STATE_READY ((FIT_FITNESS_EQUIPMENT_STATE)0) +#define FIT_FITNESS_EQUIPMENT_STATE_IN_USE ((FIT_FITNESS_EQUIPMENT_STATE)1) +#define FIT_FITNESS_EQUIPMENT_STATE_PAUSED ((FIT_FITNESS_EQUIPMENT_STATE)2) +#define FIT_FITNESS_EQUIPMENT_STATE_UNKNOWN ((FIT_FITNESS_EQUIPMENT_STATE)3) // lost connection to fitness equipment +#define FIT_FITNESS_EQUIPMENT_STATE_COUNT 4 + +typedef FIT_ENUM FIT_TONE; +#define FIT_TONE_INVALID FIT_ENUM_INVALID +#define FIT_TONE_OFF ((FIT_TONE)0) +#define FIT_TONE_TONE ((FIT_TONE)1) +#define FIT_TONE_VIBRATE ((FIT_TONE)2) +#define FIT_TONE_TONE_AND_VIBRATE ((FIT_TONE)3) +#define FIT_TONE_COUNT 4 + +typedef FIT_ENUM FIT_AUTOSCROLL; +#define FIT_AUTOSCROLL_INVALID FIT_ENUM_INVALID +#define FIT_AUTOSCROLL_NONE ((FIT_AUTOSCROLL)0) +#define FIT_AUTOSCROLL_SLOW ((FIT_AUTOSCROLL)1) +#define FIT_AUTOSCROLL_MEDIUM ((FIT_AUTOSCROLL)2) +#define FIT_AUTOSCROLL_FAST ((FIT_AUTOSCROLL)3) +#define FIT_AUTOSCROLL_COUNT 4 + +typedef FIT_ENUM FIT_ACTIVITY_CLASS; +#define FIT_ACTIVITY_CLASS_INVALID FIT_ENUM_INVALID +#define FIT_ACTIVITY_CLASS_LEVEL ((FIT_ACTIVITY_CLASS)0x7F) // 0 to 100 +#define FIT_ACTIVITY_CLASS_LEVEL_MAX ((FIT_ACTIVITY_CLASS)100) +#define FIT_ACTIVITY_CLASS_ATHLETE ((FIT_ACTIVITY_CLASS)0x80) +#define FIT_ACTIVITY_CLASS_COUNT 3 + +typedef FIT_ENUM FIT_HR_ZONE_CALC; +#define FIT_HR_ZONE_CALC_INVALID FIT_ENUM_INVALID +#define FIT_HR_ZONE_CALC_CUSTOM ((FIT_HR_ZONE_CALC)0) +#define FIT_HR_ZONE_CALC_PERCENT_MAX_HR ((FIT_HR_ZONE_CALC)1) +#define FIT_HR_ZONE_CALC_PERCENT_HRR ((FIT_HR_ZONE_CALC)2) +#define FIT_HR_ZONE_CALC_PERCENT_LTHR ((FIT_HR_ZONE_CALC)3) +#define FIT_HR_ZONE_CALC_COUNT 4 + +typedef FIT_ENUM FIT_PWR_ZONE_CALC; +#define FIT_PWR_ZONE_CALC_INVALID FIT_ENUM_INVALID +#define FIT_PWR_ZONE_CALC_CUSTOM ((FIT_PWR_ZONE_CALC)0) +#define FIT_PWR_ZONE_CALC_PERCENT_FTP ((FIT_PWR_ZONE_CALC)1) +#define FIT_PWR_ZONE_CALC_COUNT 2 + +typedef FIT_ENUM FIT_WKT_STEP_DURATION; +#define FIT_WKT_STEP_DURATION_INVALID FIT_ENUM_INVALID +#define FIT_WKT_STEP_DURATION_TIME ((FIT_WKT_STEP_DURATION)0) +#define FIT_WKT_STEP_DURATION_DISTANCE ((FIT_WKT_STEP_DURATION)1) +#define FIT_WKT_STEP_DURATION_HR_LESS_THAN ((FIT_WKT_STEP_DURATION)2) +#define FIT_WKT_STEP_DURATION_HR_GREATER_THAN ((FIT_WKT_STEP_DURATION)3) +#define FIT_WKT_STEP_DURATION_CALORIES ((FIT_WKT_STEP_DURATION)4) +#define FIT_WKT_STEP_DURATION_OPEN ((FIT_WKT_STEP_DURATION)5) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_STEPS_CMPLT ((FIT_WKT_STEP_DURATION)6) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_TIME ((FIT_WKT_STEP_DURATION)7) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_DISTANCE ((FIT_WKT_STEP_DURATION)8) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_CALORIES ((FIT_WKT_STEP_DURATION)9) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_HR_LESS_THAN ((FIT_WKT_STEP_DURATION)10) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_HR_GREATER_THAN ((FIT_WKT_STEP_DURATION)11) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_POWER_LESS_THAN ((FIT_WKT_STEP_DURATION)12) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_POWER_GREATER_THAN ((FIT_WKT_STEP_DURATION)13) +#define FIT_WKT_STEP_DURATION_POWER_LESS_THAN ((FIT_WKT_STEP_DURATION)14) +#define FIT_WKT_STEP_DURATION_POWER_GREATER_THAN ((FIT_WKT_STEP_DURATION)15) +#define FIT_WKT_STEP_DURATION_TRAINING_PEAKS_TSS ((FIT_WKT_STEP_DURATION)16) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_POWER_LAST_LAP_LESS_THAN ((FIT_WKT_STEP_DURATION)17) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_MAX_POWER_LAST_LAP_LESS_THAN ((FIT_WKT_STEP_DURATION)18) +#define FIT_WKT_STEP_DURATION_POWER_3S_LESS_THAN ((FIT_WKT_STEP_DURATION)19) +#define FIT_WKT_STEP_DURATION_POWER_10S_LESS_THAN ((FIT_WKT_STEP_DURATION)20) +#define FIT_WKT_STEP_DURATION_POWER_30S_LESS_THAN ((FIT_WKT_STEP_DURATION)21) +#define FIT_WKT_STEP_DURATION_POWER_3S_GREATER_THAN ((FIT_WKT_STEP_DURATION)22) +#define FIT_WKT_STEP_DURATION_POWER_10S_GREATER_THAN ((FIT_WKT_STEP_DURATION)23) +#define FIT_WKT_STEP_DURATION_POWER_30S_GREATER_THAN ((FIT_WKT_STEP_DURATION)24) +#define FIT_WKT_STEP_DURATION_POWER_LAP_LESS_THAN ((FIT_WKT_STEP_DURATION)25) +#define FIT_WKT_STEP_DURATION_POWER_LAP_GREATER_THAN ((FIT_WKT_STEP_DURATION)26) +#define FIT_WKT_STEP_DURATION_REPEAT_UNTIL_TRAINING_PEAKS_TSS ((FIT_WKT_STEP_DURATION)27) +#define FIT_WKT_STEP_DURATION_REPETITION_TIME ((FIT_WKT_STEP_DURATION)28) +#define FIT_WKT_STEP_DURATION_REPS ((FIT_WKT_STEP_DURATION)29) +#define FIT_WKT_STEP_DURATION_TIME_ONLY ((FIT_WKT_STEP_DURATION)31) +#define FIT_WKT_STEP_DURATION_COUNT 31 + +typedef FIT_ENUM FIT_WKT_STEP_TARGET; +#define FIT_WKT_STEP_TARGET_INVALID FIT_ENUM_INVALID +#define FIT_WKT_STEP_TARGET_SPEED ((FIT_WKT_STEP_TARGET)0) +#define FIT_WKT_STEP_TARGET_HEART_RATE ((FIT_WKT_STEP_TARGET)1) +#define FIT_WKT_STEP_TARGET_OPEN ((FIT_WKT_STEP_TARGET)2) +#define FIT_WKT_STEP_TARGET_CADENCE ((FIT_WKT_STEP_TARGET)3) +#define FIT_WKT_STEP_TARGET_POWER ((FIT_WKT_STEP_TARGET)4) +#define FIT_WKT_STEP_TARGET_GRADE ((FIT_WKT_STEP_TARGET)5) +#define FIT_WKT_STEP_TARGET_RESISTANCE ((FIT_WKT_STEP_TARGET)6) +#define FIT_WKT_STEP_TARGET_POWER_3S ((FIT_WKT_STEP_TARGET)7) +#define FIT_WKT_STEP_TARGET_POWER_10S ((FIT_WKT_STEP_TARGET)8) +#define FIT_WKT_STEP_TARGET_POWER_30S ((FIT_WKT_STEP_TARGET)9) +#define FIT_WKT_STEP_TARGET_POWER_LAP ((FIT_WKT_STEP_TARGET)10) +#define FIT_WKT_STEP_TARGET_SWIM_STROKE ((FIT_WKT_STEP_TARGET)11) +#define FIT_WKT_STEP_TARGET_SPEED_LAP ((FIT_WKT_STEP_TARGET)12) +#define FIT_WKT_STEP_TARGET_HEART_RATE_LAP ((FIT_WKT_STEP_TARGET)13) +#define FIT_WKT_STEP_TARGET_COUNT 14 + +typedef FIT_ENUM FIT_GOAL; +#define FIT_GOAL_INVALID FIT_ENUM_INVALID +#define FIT_GOAL_TIME ((FIT_GOAL)0) +#define FIT_GOAL_DISTANCE ((FIT_GOAL)1) +#define FIT_GOAL_CALORIES ((FIT_GOAL)2) +#define FIT_GOAL_FREQUENCY ((FIT_GOAL)3) +#define FIT_GOAL_STEPS ((FIT_GOAL)4) +#define FIT_GOAL_ASCENT ((FIT_GOAL)5) +#define FIT_GOAL_ACTIVE_MINUTES ((FIT_GOAL)6) +#define FIT_GOAL_COUNT 7 + +typedef FIT_ENUM FIT_GOAL_RECURRENCE; +#define FIT_GOAL_RECURRENCE_INVALID FIT_ENUM_INVALID +#define FIT_GOAL_RECURRENCE_OFF ((FIT_GOAL_RECURRENCE)0) +#define FIT_GOAL_RECURRENCE_DAILY ((FIT_GOAL_RECURRENCE)1) +#define FIT_GOAL_RECURRENCE_WEEKLY ((FIT_GOAL_RECURRENCE)2) +#define FIT_GOAL_RECURRENCE_MONTHLY ((FIT_GOAL_RECURRENCE)3) +#define FIT_GOAL_RECURRENCE_YEARLY ((FIT_GOAL_RECURRENCE)4) +#define FIT_GOAL_RECURRENCE_CUSTOM ((FIT_GOAL_RECURRENCE)5) +#define FIT_GOAL_RECURRENCE_COUNT 6 + +typedef FIT_ENUM FIT_GOAL_SOURCE; +#define FIT_GOAL_SOURCE_INVALID FIT_ENUM_INVALID +#define FIT_GOAL_SOURCE_AUTO ((FIT_GOAL_SOURCE)0) // Device generated +#define FIT_GOAL_SOURCE_COMMUNITY ((FIT_GOAL_SOURCE)1) // Social network sourced goal +#define FIT_GOAL_SOURCE_USER ((FIT_GOAL_SOURCE)2) // Manually generated +#define FIT_GOAL_SOURCE_COUNT 3 + +typedef FIT_ENUM FIT_SCHEDULE; +#define FIT_SCHEDULE_INVALID FIT_ENUM_INVALID +#define FIT_SCHEDULE_WORKOUT ((FIT_SCHEDULE)0) +#define FIT_SCHEDULE_COURSE ((FIT_SCHEDULE)1) +#define FIT_SCHEDULE_COUNT 2 + +typedef FIT_ENUM FIT_COURSE_POINT; +#define FIT_COURSE_POINT_INVALID FIT_ENUM_INVALID +#define FIT_COURSE_POINT_GENERIC ((FIT_COURSE_POINT)0) +#define FIT_COURSE_POINT_SUMMIT ((FIT_COURSE_POINT)1) +#define FIT_COURSE_POINT_VALLEY ((FIT_COURSE_POINT)2) +#define FIT_COURSE_POINT_WATER ((FIT_COURSE_POINT)3) +#define FIT_COURSE_POINT_FOOD ((FIT_COURSE_POINT)4) +#define FIT_COURSE_POINT_DANGER ((FIT_COURSE_POINT)5) +#define FIT_COURSE_POINT_LEFT ((FIT_COURSE_POINT)6) +#define FIT_COURSE_POINT_RIGHT ((FIT_COURSE_POINT)7) +#define FIT_COURSE_POINT_STRAIGHT ((FIT_COURSE_POINT)8) +#define FIT_COURSE_POINT_FIRST_AID ((FIT_COURSE_POINT)9) +#define FIT_COURSE_POINT_FOURTH_CATEGORY ((FIT_COURSE_POINT)10) +#define FIT_COURSE_POINT_THIRD_CATEGORY ((FIT_COURSE_POINT)11) +#define FIT_COURSE_POINT_SECOND_CATEGORY ((FIT_COURSE_POINT)12) +#define FIT_COURSE_POINT_FIRST_CATEGORY ((FIT_COURSE_POINT)13) +#define FIT_COURSE_POINT_HORS_CATEGORY ((FIT_COURSE_POINT)14) +#define FIT_COURSE_POINT_SPRINT ((FIT_COURSE_POINT)15) +#define FIT_COURSE_POINT_LEFT_FORK ((FIT_COURSE_POINT)16) +#define FIT_COURSE_POINT_RIGHT_FORK ((FIT_COURSE_POINT)17) +#define FIT_COURSE_POINT_MIDDLE_FORK ((FIT_COURSE_POINT)18) +#define FIT_COURSE_POINT_SLIGHT_LEFT ((FIT_COURSE_POINT)19) +#define FIT_COURSE_POINT_SHARP_LEFT ((FIT_COURSE_POINT)20) +#define FIT_COURSE_POINT_SLIGHT_RIGHT ((FIT_COURSE_POINT)21) +#define FIT_COURSE_POINT_SHARP_RIGHT ((FIT_COURSE_POINT)22) +#define FIT_COURSE_POINT_U_TURN ((FIT_COURSE_POINT)23) +#define FIT_COURSE_POINT_SEGMENT_START ((FIT_COURSE_POINT)24) +#define FIT_COURSE_POINT_SEGMENT_END ((FIT_COURSE_POINT)25) +#define FIT_COURSE_POINT_CAMPSITE ((FIT_COURSE_POINT)27) +#define FIT_COURSE_POINT_AID_STATION ((FIT_COURSE_POINT)28) +#define FIT_COURSE_POINT_REST_AREA ((FIT_COURSE_POINT)29) +#define FIT_COURSE_POINT_GENERAL_DISTANCE ((FIT_COURSE_POINT)30) // Used with UpAhead +#define FIT_COURSE_POINT_SERVICE ((FIT_COURSE_POINT)31) +#define FIT_COURSE_POINT_ENERGY_GEL ((FIT_COURSE_POINT)32) +#define FIT_COURSE_POINT_SPORTS_DRINK ((FIT_COURSE_POINT)33) +#define FIT_COURSE_POINT_MILE_MARKER ((FIT_COURSE_POINT)34) +#define FIT_COURSE_POINT_CHECKPOINT ((FIT_COURSE_POINT)35) +#define FIT_COURSE_POINT_SHELTER ((FIT_COURSE_POINT)36) +#define FIT_COURSE_POINT_MEETING_SPOT ((FIT_COURSE_POINT)37) +#define FIT_COURSE_POINT_OVERLOOK ((FIT_COURSE_POINT)38) +#define FIT_COURSE_POINT_TOILET ((FIT_COURSE_POINT)39) +#define FIT_COURSE_POINT_SHOWER ((FIT_COURSE_POINT)40) +#define FIT_COURSE_POINT_GEAR ((FIT_COURSE_POINT)41) +#define FIT_COURSE_POINT_SHARP_CURVE ((FIT_COURSE_POINT)42) +#define FIT_COURSE_POINT_STEEP_INCLINE ((FIT_COURSE_POINT)43) +#define FIT_COURSE_POINT_TUNNEL ((FIT_COURSE_POINT)44) +#define FIT_COURSE_POINT_BRIDGE ((FIT_COURSE_POINT)45) +#define FIT_COURSE_POINT_OBSTACLE ((FIT_COURSE_POINT)46) +#define FIT_COURSE_POINT_CROSSING ((FIT_COURSE_POINT)47) +#define FIT_COURSE_POINT_STORE ((FIT_COURSE_POINT)48) +#define FIT_COURSE_POINT_TRANSITION ((FIT_COURSE_POINT)49) +#define FIT_COURSE_POINT_NAVAID ((FIT_COURSE_POINT)50) +#define FIT_COURSE_POINT_TRANSPORT ((FIT_COURSE_POINT)51) +#define FIT_COURSE_POINT_ALERT ((FIT_COURSE_POINT)52) +#define FIT_COURSE_POINT_INFO ((FIT_COURSE_POINT)53) +#define FIT_COURSE_POINT_COUNT 53 + +typedef FIT_UINT16 FIT_MANUFACTURER; +#define FIT_MANUFACTURER_INVALID FIT_UINT16_INVALID +#define FIT_MANUFACTURER_GARMIN ((FIT_MANUFACTURER)1) +#define FIT_MANUFACTURER_GARMIN_FR405_ANTFS ((FIT_MANUFACTURER)2) // Do not use. Used by FR405 for ANTFS man id. +#define FIT_MANUFACTURER_ZEPHYR ((FIT_MANUFACTURER)3) +#define FIT_MANUFACTURER_DAYTON ((FIT_MANUFACTURER)4) +#define FIT_MANUFACTURER_IDT ((FIT_MANUFACTURER)5) +#define FIT_MANUFACTURER_SRM ((FIT_MANUFACTURER)6) +#define FIT_MANUFACTURER_QUARQ ((FIT_MANUFACTURER)7) +#define FIT_MANUFACTURER_IBIKE ((FIT_MANUFACTURER)8) +#define FIT_MANUFACTURER_SARIS ((FIT_MANUFACTURER)9) +#define FIT_MANUFACTURER_SPARK_HK ((FIT_MANUFACTURER)10) +#define FIT_MANUFACTURER_TANITA ((FIT_MANUFACTURER)11) +#define FIT_MANUFACTURER_ECHOWELL ((FIT_MANUFACTURER)12) +#define FIT_MANUFACTURER_DYNASTREAM_OEM ((FIT_MANUFACTURER)13) +#define FIT_MANUFACTURER_NAUTILUS ((FIT_MANUFACTURER)14) +#define FIT_MANUFACTURER_DYNASTREAM ((FIT_MANUFACTURER)15) +#define FIT_MANUFACTURER_TIMEX ((FIT_MANUFACTURER)16) +#define FIT_MANUFACTURER_METRIGEAR ((FIT_MANUFACTURER)17) +#define FIT_MANUFACTURER_XELIC ((FIT_MANUFACTURER)18) +#define FIT_MANUFACTURER_BEURER ((FIT_MANUFACTURER)19) +#define FIT_MANUFACTURER_CARDIOSPORT ((FIT_MANUFACTURER)20) +#define FIT_MANUFACTURER_A_AND_D ((FIT_MANUFACTURER)21) +#define FIT_MANUFACTURER_HMM ((FIT_MANUFACTURER)22) +#define FIT_MANUFACTURER_SUUNTO ((FIT_MANUFACTURER)23) +#define FIT_MANUFACTURER_THITA_ELEKTRONIK ((FIT_MANUFACTURER)24) +#define FIT_MANUFACTURER_GPULSE ((FIT_MANUFACTURER)25) +#define FIT_MANUFACTURER_CLEAN_MOBILE ((FIT_MANUFACTURER)26) +#define FIT_MANUFACTURER_PEDAL_BRAIN ((FIT_MANUFACTURER)27) +#define FIT_MANUFACTURER_PEAKSWARE ((FIT_MANUFACTURER)28) +#define FIT_MANUFACTURER_SAXONAR ((FIT_MANUFACTURER)29) +#define FIT_MANUFACTURER_LEMOND_FITNESS ((FIT_MANUFACTURER)30) +#define FIT_MANUFACTURER_DEXCOM ((FIT_MANUFACTURER)31) +#define FIT_MANUFACTURER_WAHOO_FITNESS ((FIT_MANUFACTURER)32) +#define FIT_MANUFACTURER_OCTANE_FITNESS ((FIT_MANUFACTURER)33) +#define FIT_MANUFACTURER_ARCHINOETICS ((FIT_MANUFACTURER)34) +#define FIT_MANUFACTURER_THE_HURT_BOX ((FIT_MANUFACTURER)35) +#define FIT_MANUFACTURER_CITIZEN_SYSTEMS ((FIT_MANUFACTURER)36) +#define FIT_MANUFACTURER_MAGELLAN ((FIT_MANUFACTURER)37) +#define FIT_MANUFACTURER_OSYNCE ((FIT_MANUFACTURER)38) +#define FIT_MANUFACTURER_HOLUX ((FIT_MANUFACTURER)39) +#define FIT_MANUFACTURER_CONCEPT2 ((FIT_MANUFACTURER)40) +#define FIT_MANUFACTURER_SHIMANO ((FIT_MANUFACTURER)41) +#define FIT_MANUFACTURER_ONE_GIANT_LEAP ((FIT_MANUFACTURER)42) +#define FIT_MANUFACTURER_ACE_SENSOR ((FIT_MANUFACTURER)43) +#define FIT_MANUFACTURER_BRIM_BROTHERS ((FIT_MANUFACTURER)44) +#define FIT_MANUFACTURER_XPLOVA ((FIT_MANUFACTURER)45) +#define FIT_MANUFACTURER_PERCEPTION_DIGITAL ((FIT_MANUFACTURER)46) +#define FIT_MANUFACTURER_BF1SYSTEMS ((FIT_MANUFACTURER)47) +#define FIT_MANUFACTURER_PIONEER ((FIT_MANUFACTURER)48) +#define FIT_MANUFACTURER_SPANTEC ((FIT_MANUFACTURER)49) +#define FIT_MANUFACTURER_METALOGICS ((FIT_MANUFACTURER)50) +#define FIT_MANUFACTURER_4IIIIS ((FIT_MANUFACTURER)51) +#define FIT_MANUFACTURER_SEIKO_EPSON ((FIT_MANUFACTURER)52) +#define FIT_MANUFACTURER_SEIKO_EPSON_OEM ((FIT_MANUFACTURER)53) +#define FIT_MANUFACTURER_IFOR_POWELL ((FIT_MANUFACTURER)54) +#define FIT_MANUFACTURER_MAXWELL_GUIDER ((FIT_MANUFACTURER)55) +#define FIT_MANUFACTURER_STAR_TRAC ((FIT_MANUFACTURER)56) +#define FIT_MANUFACTURER_BREAKAWAY ((FIT_MANUFACTURER)57) +#define FIT_MANUFACTURER_ALATECH_TECHNOLOGY_LTD ((FIT_MANUFACTURER)58) +#define FIT_MANUFACTURER_MIO_TECHNOLOGY_EUROPE ((FIT_MANUFACTURER)59) +#define FIT_MANUFACTURER_ROTOR ((FIT_MANUFACTURER)60) +#define FIT_MANUFACTURER_GEONAUTE ((FIT_MANUFACTURER)61) +#define FIT_MANUFACTURER_ID_BIKE ((FIT_MANUFACTURER)62) +#define FIT_MANUFACTURER_SPECIALIZED ((FIT_MANUFACTURER)63) +#define FIT_MANUFACTURER_WTEK ((FIT_MANUFACTURER)64) +#define FIT_MANUFACTURER_PHYSICAL_ENTERPRISES ((FIT_MANUFACTURER)65) +#define FIT_MANUFACTURER_NORTH_POLE_ENGINEERING ((FIT_MANUFACTURER)66) +#define FIT_MANUFACTURER_BKOOL ((FIT_MANUFACTURER)67) +#define FIT_MANUFACTURER_CATEYE ((FIT_MANUFACTURER)68) +#define FIT_MANUFACTURER_STAGES_CYCLING ((FIT_MANUFACTURER)69) +#define FIT_MANUFACTURER_SIGMASPORT ((FIT_MANUFACTURER)70) +#define FIT_MANUFACTURER_TOMTOM ((FIT_MANUFACTURER)71) +#define FIT_MANUFACTURER_PERIPEDAL ((FIT_MANUFACTURER)72) +#define FIT_MANUFACTURER_WATTBIKE ((FIT_MANUFACTURER)73) +#define FIT_MANUFACTURER_MOXY ((FIT_MANUFACTURER)76) +#define FIT_MANUFACTURER_CICLOSPORT ((FIT_MANUFACTURER)77) +#define FIT_MANUFACTURER_POWERBAHN ((FIT_MANUFACTURER)78) +#define FIT_MANUFACTURER_ACORN_PROJECTS_APS ((FIT_MANUFACTURER)79) +#define FIT_MANUFACTURER_LIFEBEAM ((FIT_MANUFACTURER)80) +#define FIT_MANUFACTURER_BONTRAGER ((FIT_MANUFACTURER)81) +#define FIT_MANUFACTURER_WELLGO ((FIT_MANUFACTURER)82) +#define FIT_MANUFACTURER_SCOSCHE ((FIT_MANUFACTURER)83) +#define FIT_MANUFACTURER_MAGURA ((FIT_MANUFACTURER)84) +#define FIT_MANUFACTURER_WOODWAY ((FIT_MANUFACTURER)85) +#define FIT_MANUFACTURER_ELITE ((FIT_MANUFACTURER)86) +#define FIT_MANUFACTURER_NIELSEN_KELLERMAN ((FIT_MANUFACTURER)87) +#define FIT_MANUFACTURER_DK_CITY ((FIT_MANUFACTURER)88) +#define FIT_MANUFACTURER_TACX ((FIT_MANUFACTURER)89) +#define FIT_MANUFACTURER_DIRECTION_TECHNOLOGY ((FIT_MANUFACTURER)90) +#define FIT_MANUFACTURER_MAGTONIC ((FIT_MANUFACTURER)91) +#define FIT_MANUFACTURER_1PARTCARBON ((FIT_MANUFACTURER)92) +#define FIT_MANUFACTURER_INSIDE_RIDE_TECHNOLOGIES ((FIT_MANUFACTURER)93) +#define FIT_MANUFACTURER_SOUND_OF_MOTION ((FIT_MANUFACTURER)94) +#define FIT_MANUFACTURER_STRYD ((FIT_MANUFACTURER)95) +#define FIT_MANUFACTURER_ICG ((FIT_MANUFACTURER)96) // Indoorcycling Group +#define FIT_MANUFACTURER_MIPULSE ((FIT_MANUFACTURER)97) +#define FIT_MANUFACTURER_BSX_ATHLETICS ((FIT_MANUFACTURER)98) +#define FIT_MANUFACTURER_LOOK ((FIT_MANUFACTURER)99) +#define FIT_MANUFACTURER_CAMPAGNOLO_SRL ((FIT_MANUFACTURER)100) +#define FIT_MANUFACTURER_BODY_BIKE_SMART ((FIT_MANUFACTURER)101) +#define FIT_MANUFACTURER_PRAXISWORKS ((FIT_MANUFACTURER)102) +#define FIT_MANUFACTURER_LIMITS_TECHNOLOGY ((FIT_MANUFACTURER)103) // Limits Technology Ltd. +#define FIT_MANUFACTURER_TOPACTION_TECHNOLOGY ((FIT_MANUFACTURER)104) // TopAction Technology Inc. +#define FIT_MANUFACTURER_COSINUSS ((FIT_MANUFACTURER)105) +#define FIT_MANUFACTURER_FITCARE ((FIT_MANUFACTURER)106) +#define FIT_MANUFACTURER_MAGENE ((FIT_MANUFACTURER)107) +#define FIT_MANUFACTURER_GIANT_MANUFACTURING_CO ((FIT_MANUFACTURER)108) +#define FIT_MANUFACTURER_TIGRASPORT ((FIT_MANUFACTURER)109) // Tigrasport +#define FIT_MANUFACTURER_SALUTRON ((FIT_MANUFACTURER)110) +#define FIT_MANUFACTURER_TECHNOGYM ((FIT_MANUFACTURER)111) +#define FIT_MANUFACTURER_BRYTON_SENSORS ((FIT_MANUFACTURER)112) +#define FIT_MANUFACTURER_LATITUDE_LIMITED ((FIT_MANUFACTURER)113) +#define FIT_MANUFACTURER_SOARING_TECHNOLOGY ((FIT_MANUFACTURER)114) +#define FIT_MANUFACTURER_IGPSPORT ((FIT_MANUFACTURER)115) +#define FIT_MANUFACTURER_THINKRIDER ((FIT_MANUFACTURER)116) +#define FIT_MANUFACTURER_GOPHER_SPORT ((FIT_MANUFACTURER)117) +#define FIT_MANUFACTURER_WATERROWER ((FIT_MANUFACTURER)118) +#define FIT_MANUFACTURER_ORANGETHEORY ((FIT_MANUFACTURER)119) +#define FIT_MANUFACTURER_INPEAK ((FIT_MANUFACTURER)120) +#define FIT_MANUFACTURER_KINETIC ((FIT_MANUFACTURER)121) +#define FIT_MANUFACTURER_JOHNSON_HEALTH_TECH ((FIT_MANUFACTURER)122) +#define FIT_MANUFACTURER_POLAR_ELECTRO ((FIT_MANUFACTURER)123) +#define FIT_MANUFACTURER_SEESENSE ((FIT_MANUFACTURER)124) +#define FIT_MANUFACTURER_NCI_TECHNOLOGY ((FIT_MANUFACTURER)125) +#define FIT_MANUFACTURER_IQSQUARE ((FIT_MANUFACTURER)126) +#define FIT_MANUFACTURER_LEOMO ((FIT_MANUFACTURER)127) +#define FIT_MANUFACTURER_IFIT_COM ((FIT_MANUFACTURER)128) +#define FIT_MANUFACTURER_COROS_BYTE ((FIT_MANUFACTURER)129) +#define FIT_MANUFACTURER_VERSA_DESIGN ((FIT_MANUFACTURER)130) +#define FIT_MANUFACTURER_CHILEAF ((FIT_MANUFACTURER)131) +#define FIT_MANUFACTURER_CYCPLUS ((FIT_MANUFACTURER)132) +#define FIT_MANUFACTURER_GRAVAA_BYTE ((FIT_MANUFACTURER)133) +#define FIT_MANUFACTURER_SIGEYI ((FIT_MANUFACTURER)134) +#define FIT_MANUFACTURER_COOSPO ((FIT_MANUFACTURER)135) +#define FIT_MANUFACTURER_GEOID ((FIT_MANUFACTURER)136) +#define FIT_MANUFACTURER_BOSCH ((FIT_MANUFACTURER)137) +#define FIT_MANUFACTURER_KYTO ((FIT_MANUFACTURER)138) +#define FIT_MANUFACTURER_KINETIC_SPORTS ((FIT_MANUFACTURER)139) +#define FIT_MANUFACTURER_DECATHLON_BYTE ((FIT_MANUFACTURER)140) +#define FIT_MANUFACTURER_TQ_SYSTEMS ((FIT_MANUFACTURER)141) +#define FIT_MANUFACTURER_TAG_HEUER ((FIT_MANUFACTURER)142) +#define FIT_MANUFACTURER_KEISER_FITNESS ((FIT_MANUFACTURER)143) +#define FIT_MANUFACTURER_ZWIFT_BYTE ((FIT_MANUFACTURER)144) +#define FIT_MANUFACTURER_PORSCHE_EP ((FIT_MANUFACTURER)145) +#define FIT_MANUFACTURER_BLACKBIRD ((FIT_MANUFACTURER)146) +#define FIT_MANUFACTURER_MEILAN_BYTE ((FIT_MANUFACTURER)147) +#define FIT_MANUFACTURER_EZON ((FIT_MANUFACTURER)148) +#define FIT_MANUFACTURER_LAISI ((FIT_MANUFACTURER)149) +#define FIT_MANUFACTURER_MYZONE ((FIT_MANUFACTURER)150) +#define FIT_MANUFACTURER_ABAWO ((FIT_MANUFACTURER)151) +#define FIT_MANUFACTURER_BAFANG ((FIT_MANUFACTURER)152) +#define FIT_MANUFACTURER_LUHONG_TECHNOLOGY ((FIT_MANUFACTURER)153) +#define FIT_MANUFACTURER_DEVELOPMENT ((FIT_MANUFACTURER)255) +#define FIT_MANUFACTURER_HEALTHANDLIFE ((FIT_MANUFACTURER)257) +#define FIT_MANUFACTURER_LEZYNE ((FIT_MANUFACTURER)258) +#define FIT_MANUFACTURER_SCRIBE_LABS ((FIT_MANUFACTURER)259) +#define FIT_MANUFACTURER_ZWIFT ((FIT_MANUFACTURER)260) +#define FIT_MANUFACTURER_WATTEAM ((FIT_MANUFACTURER)261) +#define FIT_MANUFACTURER_RECON ((FIT_MANUFACTURER)262) +#define FIT_MANUFACTURER_FAVERO_ELECTRONICS ((FIT_MANUFACTURER)263) +#define FIT_MANUFACTURER_DYNOVELO ((FIT_MANUFACTURER)264) +#define FIT_MANUFACTURER_STRAVA ((FIT_MANUFACTURER)265) +#define FIT_MANUFACTURER_PRECOR ((FIT_MANUFACTURER)266) // Amer Sports +#define FIT_MANUFACTURER_BRYTON ((FIT_MANUFACTURER)267) +#define FIT_MANUFACTURER_SRAM ((FIT_MANUFACTURER)268) +#define FIT_MANUFACTURER_NAVMAN ((FIT_MANUFACTURER)269) // MiTAC Global Corporation (Mio Technology) +#define FIT_MANUFACTURER_COBI ((FIT_MANUFACTURER)270) // COBI GmbH +#define FIT_MANUFACTURER_SPIVI ((FIT_MANUFACTURER)271) +#define FIT_MANUFACTURER_MIO_MAGELLAN ((FIT_MANUFACTURER)272) +#define FIT_MANUFACTURER_EVESPORTS ((FIT_MANUFACTURER)273) +#define FIT_MANUFACTURER_SENSITIVUS_GAUGE ((FIT_MANUFACTURER)274) +#define FIT_MANUFACTURER_PODOON ((FIT_MANUFACTURER)275) +#define FIT_MANUFACTURER_LIFE_TIME_FITNESS ((FIT_MANUFACTURER)276) +#define FIT_MANUFACTURER_FALCO_E_MOTORS ((FIT_MANUFACTURER)277) // Falco eMotors Inc. +#define FIT_MANUFACTURER_MINOURA ((FIT_MANUFACTURER)278) +#define FIT_MANUFACTURER_CYCLIQ ((FIT_MANUFACTURER)279) +#define FIT_MANUFACTURER_LUXOTTICA ((FIT_MANUFACTURER)280) +#define FIT_MANUFACTURER_TRAINER_ROAD ((FIT_MANUFACTURER)281) +#define FIT_MANUFACTURER_THE_SUFFERFEST ((FIT_MANUFACTURER)282) +#define FIT_MANUFACTURER_FULLSPEEDAHEAD ((FIT_MANUFACTURER)283) +#define FIT_MANUFACTURER_VIRTUALTRAINING ((FIT_MANUFACTURER)284) +#define FIT_MANUFACTURER_FEEDBACKSPORTS ((FIT_MANUFACTURER)285) +#define FIT_MANUFACTURER_OMATA ((FIT_MANUFACTURER)286) +#define FIT_MANUFACTURER_VDO ((FIT_MANUFACTURER)287) +#define FIT_MANUFACTURER_MAGNETICDAYS ((FIT_MANUFACTURER)288) +#define FIT_MANUFACTURER_HAMMERHEAD ((FIT_MANUFACTURER)289) +#define FIT_MANUFACTURER_KINETIC_BY_KURT ((FIT_MANUFACTURER)290) +#define FIT_MANUFACTURER_SHAPELOG ((FIT_MANUFACTURER)291) +#define FIT_MANUFACTURER_DABUZIDUO ((FIT_MANUFACTURER)292) +#define FIT_MANUFACTURER_JETBLACK ((FIT_MANUFACTURER)293) +#define FIT_MANUFACTURER_COROS ((FIT_MANUFACTURER)294) +#define FIT_MANUFACTURER_VIRTUGO ((FIT_MANUFACTURER)295) +#define FIT_MANUFACTURER_VELOSENSE ((FIT_MANUFACTURER)296) +#define FIT_MANUFACTURER_CYCLIGENTINC ((FIT_MANUFACTURER)297) +#define FIT_MANUFACTURER_TRAILFORKS ((FIT_MANUFACTURER)298) +#define FIT_MANUFACTURER_MAHLE_EBIKEMOTION ((FIT_MANUFACTURER)299) +#define FIT_MANUFACTURER_NURVV ((FIT_MANUFACTURER)300) +#define FIT_MANUFACTURER_MICROPROGRAM ((FIT_MANUFACTURER)301) +#define FIT_MANUFACTURER_ZONE5CLOUD ((FIT_MANUFACTURER)302) +#define FIT_MANUFACTURER_GREENTEG ((FIT_MANUFACTURER)303) +#define FIT_MANUFACTURER_YAMAHA_MOTORS ((FIT_MANUFACTURER)304) +#define FIT_MANUFACTURER_WHOOP ((FIT_MANUFACTURER)305) +#define FIT_MANUFACTURER_GRAVAA ((FIT_MANUFACTURER)306) +#define FIT_MANUFACTURER_ONELAP ((FIT_MANUFACTURER)307) +#define FIT_MANUFACTURER_MONARK_EXERCISE ((FIT_MANUFACTURER)308) +#define FIT_MANUFACTURER_FORM ((FIT_MANUFACTURER)309) +#define FIT_MANUFACTURER_DECATHLON ((FIT_MANUFACTURER)310) +#define FIT_MANUFACTURER_SYNCROS ((FIT_MANUFACTURER)311) +#define FIT_MANUFACTURER_HEATUP ((FIT_MANUFACTURER)312) +#define FIT_MANUFACTURER_CANNONDALE ((FIT_MANUFACTURER)313) +#define FIT_MANUFACTURER_TRUE_FITNESS ((FIT_MANUFACTURER)314) +#define FIT_MANUFACTURER_RGT_CYCLING ((FIT_MANUFACTURER)315) +#define FIT_MANUFACTURER_VASA ((FIT_MANUFACTURER)316) +#define FIT_MANUFACTURER_RACE_REPUBLIC ((FIT_MANUFACTURER)317) +#define FIT_MANUFACTURER_FAZUA ((FIT_MANUFACTURER)318) +#define FIT_MANUFACTURER_OREKA_TRAINING ((FIT_MANUFACTURER)319) +#define FIT_MANUFACTURER_LSEC ((FIT_MANUFACTURER)320) // Lishun Electric & Communication +#define FIT_MANUFACTURER_LULULEMON_STUDIO ((FIT_MANUFACTURER)321) +#define FIT_MANUFACTURER_SHANYUE ((FIT_MANUFACTURER)322) +#define FIT_MANUFACTURER_SPINNING_MDA ((FIT_MANUFACTURER)323) +#define FIT_MANUFACTURER_HILLDATING ((FIT_MANUFACTURER)324) +#define FIT_MANUFACTURER_AERO_SENSOR ((FIT_MANUFACTURER)325) +#define FIT_MANUFACTURER_NIKE ((FIT_MANUFACTURER)326) +#define FIT_MANUFACTURER_MAGICSHINE ((FIT_MANUFACTURER)327) +#define FIT_MANUFACTURER_ICTRAINER ((FIT_MANUFACTURER)328) +#define FIT_MANUFACTURER_ABSOLUTE_CYCLING ((FIT_MANUFACTURER)329) +#define FIT_MANUFACTURER_EO_SWIMBETTER ((FIT_MANUFACTURER)330) +#define FIT_MANUFACTURER_MYWHOOSH ((FIT_MANUFACTURER)331) +#define FIT_MANUFACTURER_RAVEMEN ((FIT_MANUFACTURER)332) +#define FIT_MANUFACTURER_TEKTRO_RACING_PRODUCTS ((FIT_MANUFACTURER)333) +#define FIT_MANUFACTURER_DARAD_INNOVATION_CORPORATION ((FIT_MANUFACTURER)334) +#define FIT_MANUFACTURER_CYCLOPTIM ((FIT_MANUFACTURER)335) +#define FIT_MANUFACTURER_RUNNA ((FIT_MANUFACTURER)337) +#define FIT_MANUFACTURER_ACTIGRAPHCORP ((FIT_MANUFACTURER)5759) +#define FIT_MANUFACTURER_COUNT 233 + +typedef FIT_UINT16 FIT_GARMIN_PRODUCT; +#define FIT_GARMIN_PRODUCT_INVALID FIT_UINT16_INVALID +#define FIT_GARMIN_PRODUCT_HRM1 ((FIT_GARMIN_PRODUCT)1) +#define FIT_GARMIN_PRODUCT_AXH01 ((FIT_GARMIN_PRODUCT)2) // AXH01 HRM chipset +#define FIT_GARMIN_PRODUCT_AXB01 ((FIT_GARMIN_PRODUCT)3) +#define FIT_GARMIN_PRODUCT_AXB02 ((FIT_GARMIN_PRODUCT)4) +#define FIT_GARMIN_PRODUCT_HRM2SS ((FIT_GARMIN_PRODUCT)5) +#define FIT_GARMIN_PRODUCT_DSI_ALF02 ((FIT_GARMIN_PRODUCT)6) +#define FIT_GARMIN_PRODUCT_HRM3SS ((FIT_GARMIN_PRODUCT)7) +#define FIT_GARMIN_PRODUCT_HRM_RUN_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)8) // hrm_run model for HRM ANT+ messaging +#define FIT_GARMIN_PRODUCT_BSM ((FIT_GARMIN_PRODUCT)9) // BSM model for ANT+ messaging +#define FIT_GARMIN_PRODUCT_BCM ((FIT_GARMIN_PRODUCT)10) // BCM model for ANT+ messaging +#define FIT_GARMIN_PRODUCT_AXS01 ((FIT_GARMIN_PRODUCT)11) // AXS01 HRM Bike Chipset model for ANT+ messaging +#define FIT_GARMIN_PRODUCT_HRM_TRI_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)12) // hrm_tri model for HRM ANT+ messaging +#define FIT_GARMIN_PRODUCT_HRM4_RUN_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)13) // hrm4 run model for HRM ANT+ messaging +#define FIT_GARMIN_PRODUCT_FR225_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)14) // fr225 model for HRM ANT+ messaging +#define FIT_GARMIN_PRODUCT_GEN3_BSM_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)15) // gen3_bsm model for Bike Speed ANT+ messaging +#define FIT_GARMIN_PRODUCT_GEN3_BCM_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)16) // gen3_bcm model for Bike Cadence ANT+ messaging +#define FIT_GARMIN_PRODUCT_HRM_FIT_SINGLE_BYTE_PRODUCT_ID ((FIT_GARMIN_PRODUCT)22) +#define FIT_GARMIN_PRODUCT_OHR ((FIT_GARMIN_PRODUCT)255) // Garmin Wearable Optical Heart Rate Sensor for ANT+ HR Profile Broadcasting +#define FIT_GARMIN_PRODUCT_FR301_CHINA ((FIT_GARMIN_PRODUCT)473) +#define FIT_GARMIN_PRODUCT_FR301_JAPAN ((FIT_GARMIN_PRODUCT)474) +#define FIT_GARMIN_PRODUCT_FR301_KOREA ((FIT_GARMIN_PRODUCT)475) +#define FIT_GARMIN_PRODUCT_FR301_TAIWAN ((FIT_GARMIN_PRODUCT)494) +#define FIT_GARMIN_PRODUCT_FR405 ((FIT_GARMIN_PRODUCT)717) // Forerunner 405 +#define FIT_GARMIN_PRODUCT_FR50 ((FIT_GARMIN_PRODUCT)782) // Forerunner 50 +#define FIT_GARMIN_PRODUCT_FR405_JAPAN ((FIT_GARMIN_PRODUCT)987) +#define FIT_GARMIN_PRODUCT_FR60 ((FIT_GARMIN_PRODUCT)988) // Forerunner 60 +#define FIT_GARMIN_PRODUCT_DSI_ALF01 ((FIT_GARMIN_PRODUCT)1011) +#define FIT_GARMIN_PRODUCT_FR310XT ((FIT_GARMIN_PRODUCT)1018) // Forerunner 310 +#define FIT_GARMIN_PRODUCT_EDGE500 ((FIT_GARMIN_PRODUCT)1036) +#define FIT_GARMIN_PRODUCT_FR110 ((FIT_GARMIN_PRODUCT)1124) // Forerunner 110 +#define FIT_GARMIN_PRODUCT_EDGE800 ((FIT_GARMIN_PRODUCT)1169) +#define FIT_GARMIN_PRODUCT_EDGE500_TAIWAN ((FIT_GARMIN_PRODUCT)1199) +#define FIT_GARMIN_PRODUCT_EDGE500_JAPAN ((FIT_GARMIN_PRODUCT)1213) +#define FIT_GARMIN_PRODUCT_CHIRP ((FIT_GARMIN_PRODUCT)1253) +#define FIT_GARMIN_PRODUCT_FR110_JAPAN ((FIT_GARMIN_PRODUCT)1274) +#define FIT_GARMIN_PRODUCT_EDGE200 ((FIT_GARMIN_PRODUCT)1325) +#define FIT_GARMIN_PRODUCT_FR910XT ((FIT_GARMIN_PRODUCT)1328) +#define FIT_GARMIN_PRODUCT_EDGE800_TAIWAN ((FIT_GARMIN_PRODUCT)1333) +#define FIT_GARMIN_PRODUCT_EDGE800_JAPAN ((FIT_GARMIN_PRODUCT)1334) +#define FIT_GARMIN_PRODUCT_ALF04 ((FIT_GARMIN_PRODUCT)1341) +#define FIT_GARMIN_PRODUCT_FR610 ((FIT_GARMIN_PRODUCT)1345) +#define FIT_GARMIN_PRODUCT_FR210_JAPAN ((FIT_GARMIN_PRODUCT)1360) +#define FIT_GARMIN_PRODUCT_VECTOR_SS ((FIT_GARMIN_PRODUCT)1380) +#define FIT_GARMIN_PRODUCT_VECTOR_CP ((FIT_GARMIN_PRODUCT)1381) +#define FIT_GARMIN_PRODUCT_EDGE800_CHINA ((FIT_GARMIN_PRODUCT)1386) +#define FIT_GARMIN_PRODUCT_EDGE500_CHINA ((FIT_GARMIN_PRODUCT)1387) +#define FIT_GARMIN_PRODUCT_APPROACH_G10 ((FIT_GARMIN_PRODUCT)1405) +#define FIT_GARMIN_PRODUCT_FR610_JAPAN ((FIT_GARMIN_PRODUCT)1410) +#define FIT_GARMIN_PRODUCT_EDGE500_KOREA ((FIT_GARMIN_PRODUCT)1422) +#define FIT_GARMIN_PRODUCT_FR70 ((FIT_GARMIN_PRODUCT)1436) +#define FIT_GARMIN_PRODUCT_FR310XT_4T ((FIT_GARMIN_PRODUCT)1446) +#define FIT_GARMIN_PRODUCT_AMX ((FIT_GARMIN_PRODUCT)1461) +#define FIT_GARMIN_PRODUCT_FR10 ((FIT_GARMIN_PRODUCT)1482) +#define FIT_GARMIN_PRODUCT_EDGE800_KOREA ((FIT_GARMIN_PRODUCT)1497) +#define FIT_GARMIN_PRODUCT_SWIM ((FIT_GARMIN_PRODUCT)1499) +#define FIT_GARMIN_PRODUCT_FR910XT_CHINA ((FIT_GARMIN_PRODUCT)1537) +#define FIT_GARMIN_PRODUCT_FENIX ((FIT_GARMIN_PRODUCT)1551) +#define FIT_GARMIN_PRODUCT_EDGE200_TAIWAN ((FIT_GARMIN_PRODUCT)1555) +#define FIT_GARMIN_PRODUCT_EDGE510 ((FIT_GARMIN_PRODUCT)1561) +#define FIT_GARMIN_PRODUCT_EDGE810 ((FIT_GARMIN_PRODUCT)1567) +#define FIT_GARMIN_PRODUCT_TEMPE ((FIT_GARMIN_PRODUCT)1570) +#define FIT_GARMIN_PRODUCT_FR910XT_JAPAN ((FIT_GARMIN_PRODUCT)1600) +#define FIT_GARMIN_PRODUCT_FR620 ((FIT_GARMIN_PRODUCT)1623) +#define FIT_GARMIN_PRODUCT_FR220 ((FIT_GARMIN_PRODUCT)1632) +#define FIT_GARMIN_PRODUCT_FR910XT_KOREA ((FIT_GARMIN_PRODUCT)1664) +#define FIT_GARMIN_PRODUCT_FR10_JAPAN ((FIT_GARMIN_PRODUCT)1688) +#define FIT_GARMIN_PRODUCT_EDGE810_JAPAN ((FIT_GARMIN_PRODUCT)1721) +#define FIT_GARMIN_PRODUCT_VIRB_ELITE ((FIT_GARMIN_PRODUCT)1735) +#define FIT_GARMIN_PRODUCT_EDGE_TOURING ((FIT_GARMIN_PRODUCT)1736) // Also Edge Touring Plus +#define FIT_GARMIN_PRODUCT_EDGE510_JAPAN ((FIT_GARMIN_PRODUCT)1742) +#define FIT_GARMIN_PRODUCT_HRM_TRI ((FIT_GARMIN_PRODUCT)1743) // Also HRM-Swim +#define FIT_GARMIN_PRODUCT_HRM_RUN ((FIT_GARMIN_PRODUCT)1752) +#define FIT_GARMIN_PRODUCT_FR920XT ((FIT_GARMIN_PRODUCT)1765) +#define FIT_GARMIN_PRODUCT_EDGE510_ASIA ((FIT_GARMIN_PRODUCT)1821) +#define FIT_GARMIN_PRODUCT_EDGE810_CHINA ((FIT_GARMIN_PRODUCT)1822) +#define FIT_GARMIN_PRODUCT_EDGE810_TAIWAN ((FIT_GARMIN_PRODUCT)1823) +#define FIT_GARMIN_PRODUCT_EDGE1000 ((FIT_GARMIN_PRODUCT)1836) +#define FIT_GARMIN_PRODUCT_VIVO_FIT ((FIT_GARMIN_PRODUCT)1837) +#define FIT_GARMIN_PRODUCT_VIRB_REMOTE ((FIT_GARMIN_PRODUCT)1853) +#define FIT_GARMIN_PRODUCT_VIVO_KI ((FIT_GARMIN_PRODUCT)1885) +#define FIT_GARMIN_PRODUCT_FR15 ((FIT_GARMIN_PRODUCT)1903) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE ((FIT_GARMIN_PRODUCT)1907) +#define FIT_GARMIN_PRODUCT_EDGE510_KOREA ((FIT_GARMIN_PRODUCT)1918) +#define FIT_GARMIN_PRODUCT_FR620_JAPAN ((FIT_GARMIN_PRODUCT)1928) +#define FIT_GARMIN_PRODUCT_FR620_CHINA ((FIT_GARMIN_PRODUCT)1929) +#define FIT_GARMIN_PRODUCT_FR220_JAPAN ((FIT_GARMIN_PRODUCT)1930) +#define FIT_GARMIN_PRODUCT_FR220_CHINA ((FIT_GARMIN_PRODUCT)1931) +#define FIT_GARMIN_PRODUCT_APPROACH_S6 ((FIT_GARMIN_PRODUCT)1936) +#define FIT_GARMIN_PRODUCT_VIVO_SMART ((FIT_GARMIN_PRODUCT)1956) +#define FIT_GARMIN_PRODUCT_FENIX2 ((FIT_GARMIN_PRODUCT)1967) +#define FIT_GARMIN_PRODUCT_EPIX ((FIT_GARMIN_PRODUCT)1988) +#define FIT_GARMIN_PRODUCT_FENIX3 ((FIT_GARMIN_PRODUCT)2050) +#define FIT_GARMIN_PRODUCT_EDGE1000_TAIWAN ((FIT_GARMIN_PRODUCT)2052) +#define FIT_GARMIN_PRODUCT_EDGE1000_JAPAN ((FIT_GARMIN_PRODUCT)2053) +#define FIT_GARMIN_PRODUCT_FR15_JAPAN ((FIT_GARMIN_PRODUCT)2061) +#define FIT_GARMIN_PRODUCT_EDGE520 ((FIT_GARMIN_PRODUCT)2067) +#define FIT_GARMIN_PRODUCT_EDGE1000_CHINA ((FIT_GARMIN_PRODUCT)2070) +#define FIT_GARMIN_PRODUCT_FR620_RUSSIA ((FIT_GARMIN_PRODUCT)2072) +#define FIT_GARMIN_PRODUCT_FR220_RUSSIA ((FIT_GARMIN_PRODUCT)2073) +#define FIT_GARMIN_PRODUCT_VECTOR_S ((FIT_GARMIN_PRODUCT)2079) +#define FIT_GARMIN_PRODUCT_EDGE1000_KOREA ((FIT_GARMIN_PRODUCT)2100) +#define FIT_GARMIN_PRODUCT_FR920XT_TAIWAN ((FIT_GARMIN_PRODUCT)2130) +#define FIT_GARMIN_PRODUCT_FR920XT_CHINA ((FIT_GARMIN_PRODUCT)2131) +#define FIT_GARMIN_PRODUCT_FR920XT_JAPAN ((FIT_GARMIN_PRODUCT)2132) +#define FIT_GARMIN_PRODUCT_VIRBX ((FIT_GARMIN_PRODUCT)2134) +#define FIT_GARMIN_PRODUCT_VIVO_SMART_APAC ((FIT_GARMIN_PRODUCT)2135) +#define FIT_GARMIN_PRODUCT_ETREX_TOUCH ((FIT_GARMIN_PRODUCT)2140) +#define FIT_GARMIN_PRODUCT_EDGE25 ((FIT_GARMIN_PRODUCT)2147) +#define FIT_GARMIN_PRODUCT_FR25 ((FIT_GARMIN_PRODUCT)2148) +#define FIT_GARMIN_PRODUCT_VIVO_FIT2 ((FIT_GARMIN_PRODUCT)2150) +#define FIT_GARMIN_PRODUCT_FR225 ((FIT_GARMIN_PRODUCT)2153) +#define FIT_GARMIN_PRODUCT_FR630 ((FIT_GARMIN_PRODUCT)2156) +#define FIT_GARMIN_PRODUCT_FR230 ((FIT_GARMIN_PRODUCT)2157) +#define FIT_GARMIN_PRODUCT_FR735XT ((FIT_GARMIN_PRODUCT)2158) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE_APAC ((FIT_GARMIN_PRODUCT)2160) +#define FIT_GARMIN_PRODUCT_VECTOR_2 ((FIT_GARMIN_PRODUCT)2161) +#define FIT_GARMIN_PRODUCT_VECTOR_2S ((FIT_GARMIN_PRODUCT)2162) +#define FIT_GARMIN_PRODUCT_VIRBXE ((FIT_GARMIN_PRODUCT)2172) +#define FIT_GARMIN_PRODUCT_FR620_TAIWAN ((FIT_GARMIN_PRODUCT)2173) +#define FIT_GARMIN_PRODUCT_FR220_TAIWAN ((FIT_GARMIN_PRODUCT)2174) +#define FIT_GARMIN_PRODUCT_TRUSWING ((FIT_GARMIN_PRODUCT)2175) +#define FIT_GARMIN_PRODUCT_D2AIRVENU ((FIT_GARMIN_PRODUCT)2187) +#define FIT_GARMIN_PRODUCT_FENIX3_CHINA ((FIT_GARMIN_PRODUCT)2188) +#define FIT_GARMIN_PRODUCT_FENIX3_TWN ((FIT_GARMIN_PRODUCT)2189) +#define FIT_GARMIN_PRODUCT_VARIA_HEADLIGHT ((FIT_GARMIN_PRODUCT)2192) +#define FIT_GARMIN_PRODUCT_VARIA_TAILLIGHT_OLD ((FIT_GARMIN_PRODUCT)2193) +#define FIT_GARMIN_PRODUCT_EDGE_EXPLORE_1000 ((FIT_GARMIN_PRODUCT)2204) +#define FIT_GARMIN_PRODUCT_FR225_ASIA ((FIT_GARMIN_PRODUCT)2219) +#define FIT_GARMIN_PRODUCT_VARIA_RADAR_TAILLIGHT ((FIT_GARMIN_PRODUCT)2225) +#define FIT_GARMIN_PRODUCT_VARIA_RADAR_DISPLAY ((FIT_GARMIN_PRODUCT)2226) +#define FIT_GARMIN_PRODUCT_EDGE20 ((FIT_GARMIN_PRODUCT)2238) +#define FIT_GARMIN_PRODUCT_EDGE520_ASIA ((FIT_GARMIN_PRODUCT)2260) +#define FIT_GARMIN_PRODUCT_EDGE520_JAPAN ((FIT_GARMIN_PRODUCT)2261) +#define FIT_GARMIN_PRODUCT_D2_BRAVO ((FIT_GARMIN_PRODUCT)2262) +#define FIT_GARMIN_PRODUCT_APPROACH_S20 ((FIT_GARMIN_PRODUCT)2266) +#define FIT_GARMIN_PRODUCT_VIVO_SMART2 ((FIT_GARMIN_PRODUCT)2271) +#define FIT_GARMIN_PRODUCT_EDGE1000_THAI ((FIT_GARMIN_PRODUCT)2274) +#define FIT_GARMIN_PRODUCT_VARIA_REMOTE ((FIT_GARMIN_PRODUCT)2276) +#define FIT_GARMIN_PRODUCT_EDGE25_ASIA ((FIT_GARMIN_PRODUCT)2288) +#define FIT_GARMIN_PRODUCT_EDGE25_JPN ((FIT_GARMIN_PRODUCT)2289) +#define FIT_GARMIN_PRODUCT_EDGE20_ASIA ((FIT_GARMIN_PRODUCT)2290) +#define FIT_GARMIN_PRODUCT_APPROACH_X40 ((FIT_GARMIN_PRODUCT)2292) +#define FIT_GARMIN_PRODUCT_FENIX3_JAPAN ((FIT_GARMIN_PRODUCT)2293) +#define FIT_GARMIN_PRODUCT_VIVO_SMART_EMEA ((FIT_GARMIN_PRODUCT)2294) +#define FIT_GARMIN_PRODUCT_FR630_ASIA ((FIT_GARMIN_PRODUCT)2310) +#define FIT_GARMIN_PRODUCT_FR630_JPN ((FIT_GARMIN_PRODUCT)2311) +#define FIT_GARMIN_PRODUCT_FR230_JPN ((FIT_GARMIN_PRODUCT)2313) +#define FIT_GARMIN_PRODUCT_HRM4_RUN ((FIT_GARMIN_PRODUCT)2327) +#define FIT_GARMIN_PRODUCT_EPIX_JAPAN ((FIT_GARMIN_PRODUCT)2332) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE_HR ((FIT_GARMIN_PRODUCT)2337) +#define FIT_GARMIN_PRODUCT_VIVO_SMART_GPS_HR ((FIT_GARMIN_PRODUCT)2347) +#define FIT_GARMIN_PRODUCT_VIVO_SMART_HR ((FIT_GARMIN_PRODUCT)2348) +#define FIT_GARMIN_PRODUCT_VIVO_SMART_HR_ASIA ((FIT_GARMIN_PRODUCT)2361) +#define FIT_GARMIN_PRODUCT_VIVO_SMART_GPS_HR_ASIA ((FIT_GARMIN_PRODUCT)2362) +#define FIT_GARMIN_PRODUCT_VIVO_MOVE ((FIT_GARMIN_PRODUCT)2368) +#define FIT_GARMIN_PRODUCT_VARIA_TAILLIGHT ((FIT_GARMIN_PRODUCT)2379) +#define FIT_GARMIN_PRODUCT_FR235_ASIA ((FIT_GARMIN_PRODUCT)2396) +#define FIT_GARMIN_PRODUCT_FR235_JAPAN ((FIT_GARMIN_PRODUCT)2397) +#define FIT_GARMIN_PRODUCT_VARIA_VISION ((FIT_GARMIN_PRODUCT)2398) +#define FIT_GARMIN_PRODUCT_VIVO_FIT3 ((FIT_GARMIN_PRODUCT)2406) +#define FIT_GARMIN_PRODUCT_FENIX3_KOREA ((FIT_GARMIN_PRODUCT)2407) +#define FIT_GARMIN_PRODUCT_FENIX3_SEA ((FIT_GARMIN_PRODUCT)2408) +#define FIT_GARMIN_PRODUCT_FENIX3_HR ((FIT_GARMIN_PRODUCT)2413) +#define FIT_GARMIN_PRODUCT_VIRB_ULTRA_30 ((FIT_GARMIN_PRODUCT)2417) +#define FIT_GARMIN_PRODUCT_INDEX_SMART_SCALE ((FIT_GARMIN_PRODUCT)2429) +#define FIT_GARMIN_PRODUCT_FR235 ((FIT_GARMIN_PRODUCT)2431) +#define FIT_GARMIN_PRODUCT_FENIX3_CHRONOS ((FIT_GARMIN_PRODUCT)2432) +#define FIT_GARMIN_PRODUCT_OREGON7XX ((FIT_GARMIN_PRODUCT)2441) +#define FIT_GARMIN_PRODUCT_RINO7XX ((FIT_GARMIN_PRODUCT)2444) +#define FIT_GARMIN_PRODUCT_EPIX_KOREA ((FIT_GARMIN_PRODUCT)2457) +#define FIT_GARMIN_PRODUCT_FENIX3_HR_CHN ((FIT_GARMIN_PRODUCT)2473) +#define FIT_GARMIN_PRODUCT_FENIX3_HR_TWN ((FIT_GARMIN_PRODUCT)2474) +#define FIT_GARMIN_PRODUCT_FENIX3_HR_JPN ((FIT_GARMIN_PRODUCT)2475) +#define FIT_GARMIN_PRODUCT_FENIX3_HR_SEA ((FIT_GARMIN_PRODUCT)2476) +#define FIT_GARMIN_PRODUCT_FENIX3_HR_KOR ((FIT_GARMIN_PRODUCT)2477) +#define FIT_GARMIN_PRODUCT_NAUTIX ((FIT_GARMIN_PRODUCT)2496) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE_HR_APAC ((FIT_GARMIN_PRODUCT)2497) +#define FIT_GARMIN_PRODUCT_FR35 ((FIT_GARMIN_PRODUCT)2503) +#define FIT_GARMIN_PRODUCT_OREGON7XX_WW ((FIT_GARMIN_PRODUCT)2512) +#define FIT_GARMIN_PRODUCT_EDGE_820 ((FIT_GARMIN_PRODUCT)2530) +#define FIT_GARMIN_PRODUCT_EDGE_EXPLORE_820 ((FIT_GARMIN_PRODUCT)2531) +#define FIT_GARMIN_PRODUCT_FR735XT_APAC ((FIT_GARMIN_PRODUCT)2533) +#define FIT_GARMIN_PRODUCT_FR735XT_JAPAN ((FIT_GARMIN_PRODUCT)2534) +#define FIT_GARMIN_PRODUCT_FENIX5S ((FIT_GARMIN_PRODUCT)2544) +#define FIT_GARMIN_PRODUCT_D2_BRAVO_TITANIUM ((FIT_GARMIN_PRODUCT)2547) +#define FIT_GARMIN_PRODUCT_VARIA_UT800 ((FIT_GARMIN_PRODUCT)2567) // Varia UT 800 SW +#define FIT_GARMIN_PRODUCT_RUNNING_DYNAMICS_POD ((FIT_GARMIN_PRODUCT)2593) +#define FIT_GARMIN_PRODUCT_EDGE_820_CHINA ((FIT_GARMIN_PRODUCT)2599) +#define FIT_GARMIN_PRODUCT_EDGE_820_JAPAN ((FIT_GARMIN_PRODUCT)2600) +#define FIT_GARMIN_PRODUCT_FENIX5X ((FIT_GARMIN_PRODUCT)2604) +#define FIT_GARMIN_PRODUCT_VIVO_FIT_JR ((FIT_GARMIN_PRODUCT)2606) +#define FIT_GARMIN_PRODUCT_VIVO_SMART3 ((FIT_GARMIN_PRODUCT)2622) +#define FIT_GARMIN_PRODUCT_VIVO_SPORT ((FIT_GARMIN_PRODUCT)2623) +#define FIT_GARMIN_PRODUCT_EDGE_820_TAIWAN ((FIT_GARMIN_PRODUCT)2628) +#define FIT_GARMIN_PRODUCT_EDGE_820_KOREA ((FIT_GARMIN_PRODUCT)2629) +#define FIT_GARMIN_PRODUCT_EDGE_820_SEA ((FIT_GARMIN_PRODUCT)2630) +#define FIT_GARMIN_PRODUCT_FR35_HEBREW ((FIT_GARMIN_PRODUCT)2650) +#define FIT_GARMIN_PRODUCT_APPROACH_S60 ((FIT_GARMIN_PRODUCT)2656) +#define FIT_GARMIN_PRODUCT_FR35_APAC ((FIT_GARMIN_PRODUCT)2667) +#define FIT_GARMIN_PRODUCT_FR35_JAPAN ((FIT_GARMIN_PRODUCT)2668) +#define FIT_GARMIN_PRODUCT_FENIX3_CHRONOS_ASIA ((FIT_GARMIN_PRODUCT)2675) +#define FIT_GARMIN_PRODUCT_VIRB_360 ((FIT_GARMIN_PRODUCT)2687) +#define FIT_GARMIN_PRODUCT_FR935 ((FIT_GARMIN_PRODUCT)2691) +#define FIT_GARMIN_PRODUCT_FENIX5 ((FIT_GARMIN_PRODUCT)2697) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE3 ((FIT_GARMIN_PRODUCT)2700) +#define FIT_GARMIN_PRODUCT_FR235_CHINA_NFC ((FIT_GARMIN_PRODUCT)2733) +#define FIT_GARMIN_PRODUCT_FORETREX_601_701 ((FIT_GARMIN_PRODUCT)2769) +#define FIT_GARMIN_PRODUCT_VIVO_MOVE_HR ((FIT_GARMIN_PRODUCT)2772) +#define FIT_GARMIN_PRODUCT_EDGE_1030 ((FIT_GARMIN_PRODUCT)2713) +#define FIT_GARMIN_PRODUCT_FR35_SEA ((FIT_GARMIN_PRODUCT)2727) +#define FIT_GARMIN_PRODUCT_VECTOR_3 ((FIT_GARMIN_PRODUCT)2787) +#define FIT_GARMIN_PRODUCT_FENIX5_ASIA ((FIT_GARMIN_PRODUCT)2796) +#define FIT_GARMIN_PRODUCT_FENIX5S_ASIA ((FIT_GARMIN_PRODUCT)2797) +#define FIT_GARMIN_PRODUCT_FENIX5X_ASIA ((FIT_GARMIN_PRODUCT)2798) +#define FIT_GARMIN_PRODUCT_APPROACH_Z80 ((FIT_GARMIN_PRODUCT)2806) +#define FIT_GARMIN_PRODUCT_FR35_KOREA ((FIT_GARMIN_PRODUCT)2814) +#define FIT_GARMIN_PRODUCT_D2CHARLIE ((FIT_GARMIN_PRODUCT)2819) +#define FIT_GARMIN_PRODUCT_VIVO_SMART3_APAC ((FIT_GARMIN_PRODUCT)2831) +#define FIT_GARMIN_PRODUCT_VIVO_SPORT_APAC ((FIT_GARMIN_PRODUCT)2832) +#define FIT_GARMIN_PRODUCT_FR935_ASIA ((FIT_GARMIN_PRODUCT)2833) +#define FIT_GARMIN_PRODUCT_DESCENT ((FIT_GARMIN_PRODUCT)2859) +#define FIT_GARMIN_PRODUCT_VIVO_FIT4 ((FIT_GARMIN_PRODUCT)2878) +#define FIT_GARMIN_PRODUCT_FR645 ((FIT_GARMIN_PRODUCT)2886) +#define FIT_GARMIN_PRODUCT_FR645M ((FIT_GARMIN_PRODUCT)2888) +#define FIT_GARMIN_PRODUCT_FR30 ((FIT_GARMIN_PRODUCT)2891) +#define FIT_GARMIN_PRODUCT_FENIX5S_PLUS ((FIT_GARMIN_PRODUCT)2900) +#define FIT_GARMIN_PRODUCT_EDGE_130 ((FIT_GARMIN_PRODUCT)2909) +#define FIT_GARMIN_PRODUCT_EDGE_1030_ASIA ((FIT_GARMIN_PRODUCT)2924) +#define FIT_GARMIN_PRODUCT_VIVOSMART_4 ((FIT_GARMIN_PRODUCT)2927) +#define FIT_GARMIN_PRODUCT_VIVO_MOVE_HR_ASIA ((FIT_GARMIN_PRODUCT)2945) +#define FIT_GARMIN_PRODUCT_APPROACH_X10 ((FIT_GARMIN_PRODUCT)2962) +#define FIT_GARMIN_PRODUCT_FR30_ASIA ((FIT_GARMIN_PRODUCT)2977) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE3M_W ((FIT_GARMIN_PRODUCT)2988) +#define FIT_GARMIN_PRODUCT_FR645_ASIA ((FIT_GARMIN_PRODUCT)3003) +#define FIT_GARMIN_PRODUCT_FR645M_ASIA ((FIT_GARMIN_PRODUCT)3004) +#define FIT_GARMIN_PRODUCT_EDGE_EXPLORE ((FIT_GARMIN_PRODUCT)3011) +#define FIT_GARMIN_PRODUCT_GPSMAP66 ((FIT_GARMIN_PRODUCT)3028) +#define FIT_GARMIN_PRODUCT_APPROACH_S10 ((FIT_GARMIN_PRODUCT)3049) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE3M_L ((FIT_GARMIN_PRODUCT)3066) +#define FIT_GARMIN_PRODUCT_FR245 ((FIT_GARMIN_PRODUCT)3076) +#define FIT_GARMIN_PRODUCT_FR245_MUSIC ((FIT_GARMIN_PRODUCT)3077) +#define FIT_GARMIN_PRODUCT_APPROACH_G80 ((FIT_GARMIN_PRODUCT)3085) +#define FIT_GARMIN_PRODUCT_EDGE_130_ASIA ((FIT_GARMIN_PRODUCT)3092) +#define FIT_GARMIN_PRODUCT_EDGE_1030_BONTRAGER ((FIT_GARMIN_PRODUCT)3095) +#define FIT_GARMIN_PRODUCT_FENIX5_PLUS ((FIT_GARMIN_PRODUCT)3110) +#define FIT_GARMIN_PRODUCT_FENIX5X_PLUS ((FIT_GARMIN_PRODUCT)3111) +#define FIT_GARMIN_PRODUCT_EDGE_520_PLUS ((FIT_GARMIN_PRODUCT)3112) +#define FIT_GARMIN_PRODUCT_FR945 ((FIT_GARMIN_PRODUCT)3113) +#define FIT_GARMIN_PRODUCT_EDGE_530 ((FIT_GARMIN_PRODUCT)3121) +#define FIT_GARMIN_PRODUCT_EDGE_830 ((FIT_GARMIN_PRODUCT)3122) +#define FIT_GARMIN_PRODUCT_INSTINCT_ESPORTS ((FIT_GARMIN_PRODUCT)3126) +#define FIT_GARMIN_PRODUCT_FENIX5S_PLUS_APAC ((FIT_GARMIN_PRODUCT)3134) +#define FIT_GARMIN_PRODUCT_FENIX5X_PLUS_APAC ((FIT_GARMIN_PRODUCT)3135) +#define FIT_GARMIN_PRODUCT_EDGE_520_PLUS_APAC ((FIT_GARMIN_PRODUCT)3142) +#define FIT_GARMIN_PRODUCT_DESCENT_T1 ((FIT_GARMIN_PRODUCT)3143) +#define FIT_GARMIN_PRODUCT_FR235L_ASIA ((FIT_GARMIN_PRODUCT)3144) +#define FIT_GARMIN_PRODUCT_FR245_ASIA ((FIT_GARMIN_PRODUCT)3145) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE3M_APAC ((FIT_GARMIN_PRODUCT)3163) +#define FIT_GARMIN_PRODUCT_GEN3_BSM ((FIT_GARMIN_PRODUCT)3192) // gen3 bike speed sensor +#define FIT_GARMIN_PRODUCT_GEN3_BCM ((FIT_GARMIN_PRODUCT)3193) // gen3 bike cadence sensor +#define FIT_GARMIN_PRODUCT_VIVO_SMART4_ASIA ((FIT_GARMIN_PRODUCT)3218) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE4_SMALL ((FIT_GARMIN_PRODUCT)3224) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE4_LARGE ((FIT_GARMIN_PRODUCT)3225) +#define FIT_GARMIN_PRODUCT_VENU ((FIT_GARMIN_PRODUCT)3226) +#define FIT_GARMIN_PRODUCT_MARQ_DRIVER ((FIT_GARMIN_PRODUCT)3246) +#define FIT_GARMIN_PRODUCT_MARQ_AVIATOR ((FIT_GARMIN_PRODUCT)3247) +#define FIT_GARMIN_PRODUCT_MARQ_CAPTAIN ((FIT_GARMIN_PRODUCT)3248) +#define FIT_GARMIN_PRODUCT_MARQ_COMMANDER ((FIT_GARMIN_PRODUCT)3249) +#define FIT_GARMIN_PRODUCT_MARQ_EXPEDITION ((FIT_GARMIN_PRODUCT)3250) +#define FIT_GARMIN_PRODUCT_MARQ_ATHLETE ((FIT_GARMIN_PRODUCT)3251) +#define FIT_GARMIN_PRODUCT_DESCENT_MK2 ((FIT_GARMIN_PRODUCT)3258) +#define FIT_GARMIN_PRODUCT_FR45 ((FIT_GARMIN_PRODUCT)3282) +#define FIT_GARMIN_PRODUCT_GPSMAP66I ((FIT_GARMIN_PRODUCT)3284) +#define FIT_GARMIN_PRODUCT_FENIX6S_SPORT ((FIT_GARMIN_PRODUCT)3287) +#define FIT_GARMIN_PRODUCT_FENIX6S ((FIT_GARMIN_PRODUCT)3288) +#define FIT_GARMIN_PRODUCT_FENIX6_SPORT ((FIT_GARMIN_PRODUCT)3289) +#define FIT_GARMIN_PRODUCT_FENIX6 ((FIT_GARMIN_PRODUCT)3290) +#define FIT_GARMIN_PRODUCT_FENIX6X ((FIT_GARMIN_PRODUCT)3291) +#define FIT_GARMIN_PRODUCT_HRM_DUAL ((FIT_GARMIN_PRODUCT)3299) // HRM-Dual +#define FIT_GARMIN_PRODUCT_HRM_PRO ((FIT_GARMIN_PRODUCT)3300) // HRM-Pro +#define FIT_GARMIN_PRODUCT_VIVO_MOVE3_PREMIUM ((FIT_GARMIN_PRODUCT)3308) +#define FIT_GARMIN_PRODUCT_APPROACH_S40 ((FIT_GARMIN_PRODUCT)3314) +#define FIT_GARMIN_PRODUCT_FR245M_ASIA ((FIT_GARMIN_PRODUCT)3321) +#define FIT_GARMIN_PRODUCT_EDGE_530_APAC ((FIT_GARMIN_PRODUCT)3349) +#define FIT_GARMIN_PRODUCT_EDGE_830_APAC ((FIT_GARMIN_PRODUCT)3350) +#define FIT_GARMIN_PRODUCT_VIVO_MOVE3 ((FIT_GARMIN_PRODUCT)3378) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE4_SMALL_ASIA ((FIT_GARMIN_PRODUCT)3387) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE4_LARGE_ASIA ((FIT_GARMIN_PRODUCT)3388) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE4_OLED_ASIA ((FIT_GARMIN_PRODUCT)3389) +#define FIT_GARMIN_PRODUCT_SWIM2 ((FIT_GARMIN_PRODUCT)3405) +#define FIT_GARMIN_PRODUCT_MARQ_DRIVER_ASIA ((FIT_GARMIN_PRODUCT)3420) +#define FIT_GARMIN_PRODUCT_MARQ_AVIATOR_ASIA ((FIT_GARMIN_PRODUCT)3421) +#define FIT_GARMIN_PRODUCT_VIVO_MOVE3_ASIA ((FIT_GARMIN_PRODUCT)3422) +#define FIT_GARMIN_PRODUCT_FR945_ASIA ((FIT_GARMIN_PRODUCT)3441) +#define FIT_GARMIN_PRODUCT_VIVO_ACTIVE3T_CHN ((FIT_GARMIN_PRODUCT)3446) +#define FIT_GARMIN_PRODUCT_MARQ_CAPTAIN_ASIA ((FIT_GARMIN_PRODUCT)3448) +#define FIT_GARMIN_PRODUCT_MARQ_COMMANDER_ASIA ((FIT_GARMIN_PRODUCT)3449) +#define FIT_GARMIN_PRODUCT_MARQ_EXPEDITION_ASIA ((FIT_GARMIN_PRODUCT)3450) +#define FIT_GARMIN_PRODUCT_MARQ_ATHLETE_ASIA ((FIT_GARMIN_PRODUCT)3451) +#define FIT_GARMIN_PRODUCT_INDEX_SMART_SCALE_2 ((FIT_GARMIN_PRODUCT)3461) +#define FIT_GARMIN_PRODUCT_INSTINCT_SOLAR ((FIT_GARMIN_PRODUCT)3466) +#define FIT_GARMIN_PRODUCT_FR45_ASIA ((FIT_GARMIN_PRODUCT)3469) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE3_DAIMLER ((FIT_GARMIN_PRODUCT)3473) +#define FIT_GARMIN_PRODUCT_LEGACY_REY ((FIT_GARMIN_PRODUCT)3498) +#define FIT_GARMIN_PRODUCT_LEGACY_DARTH_VADER ((FIT_GARMIN_PRODUCT)3499) +#define FIT_GARMIN_PRODUCT_LEGACY_CAPTAIN_MARVEL ((FIT_GARMIN_PRODUCT)3500) +#define FIT_GARMIN_PRODUCT_LEGACY_FIRST_AVENGER ((FIT_GARMIN_PRODUCT)3501) +#define FIT_GARMIN_PRODUCT_FENIX6S_SPORT_ASIA ((FIT_GARMIN_PRODUCT)3512) +#define FIT_GARMIN_PRODUCT_FENIX6S_ASIA ((FIT_GARMIN_PRODUCT)3513) +#define FIT_GARMIN_PRODUCT_FENIX6_SPORT_ASIA ((FIT_GARMIN_PRODUCT)3514) +#define FIT_GARMIN_PRODUCT_FENIX6_ASIA ((FIT_GARMIN_PRODUCT)3515) +#define FIT_GARMIN_PRODUCT_FENIX6X_ASIA ((FIT_GARMIN_PRODUCT)3516) +#define FIT_GARMIN_PRODUCT_LEGACY_CAPTAIN_MARVEL_ASIA ((FIT_GARMIN_PRODUCT)3535) +#define FIT_GARMIN_PRODUCT_LEGACY_FIRST_AVENGER_ASIA ((FIT_GARMIN_PRODUCT)3536) +#define FIT_GARMIN_PRODUCT_LEGACY_REY_ASIA ((FIT_GARMIN_PRODUCT)3537) +#define FIT_GARMIN_PRODUCT_LEGACY_DARTH_VADER_ASIA ((FIT_GARMIN_PRODUCT)3538) +#define FIT_GARMIN_PRODUCT_DESCENT_MK2S ((FIT_GARMIN_PRODUCT)3542) +#define FIT_GARMIN_PRODUCT_EDGE_130_PLUS ((FIT_GARMIN_PRODUCT)3558) +#define FIT_GARMIN_PRODUCT_EDGE_1030_PLUS ((FIT_GARMIN_PRODUCT)3570) +#define FIT_GARMIN_PRODUCT_RALLY_200 ((FIT_GARMIN_PRODUCT)3578) // Rally 100/200 Power Meter Series +#define FIT_GARMIN_PRODUCT_FR745 ((FIT_GARMIN_PRODUCT)3589) +#define FIT_GARMIN_PRODUCT_VENUSQ_MUSIC ((FIT_GARMIN_PRODUCT)3596) +#define FIT_GARMIN_PRODUCT_VENUSQ_MUSIC_V2 ((FIT_GARMIN_PRODUCT)3599) +#define FIT_GARMIN_PRODUCT_VENUSQ ((FIT_GARMIN_PRODUCT)3600) +#define FIT_GARMIN_PRODUCT_LILY ((FIT_GARMIN_PRODUCT)3615) +#define FIT_GARMIN_PRODUCT_MARQ_ADVENTURER ((FIT_GARMIN_PRODUCT)3624) +#define FIT_GARMIN_PRODUCT_ENDURO ((FIT_GARMIN_PRODUCT)3638) +#define FIT_GARMIN_PRODUCT_SWIM2_APAC ((FIT_GARMIN_PRODUCT)3639) +#define FIT_GARMIN_PRODUCT_MARQ_ADVENTURER_ASIA ((FIT_GARMIN_PRODUCT)3648) +#define FIT_GARMIN_PRODUCT_FR945_LTE ((FIT_GARMIN_PRODUCT)3652) +#define FIT_GARMIN_PRODUCT_DESCENT_MK2_ASIA ((FIT_GARMIN_PRODUCT)3702) // Mk2 and Mk2i +#define FIT_GARMIN_PRODUCT_VENU2 ((FIT_GARMIN_PRODUCT)3703) +#define FIT_GARMIN_PRODUCT_VENU2S ((FIT_GARMIN_PRODUCT)3704) +#define FIT_GARMIN_PRODUCT_VENU_DAIMLER_ASIA ((FIT_GARMIN_PRODUCT)3737) +#define FIT_GARMIN_PRODUCT_MARQ_GOLFER ((FIT_GARMIN_PRODUCT)3739) +#define FIT_GARMIN_PRODUCT_VENU_DAIMLER ((FIT_GARMIN_PRODUCT)3740) +#define FIT_GARMIN_PRODUCT_FR745_ASIA ((FIT_GARMIN_PRODUCT)3794) +#define FIT_GARMIN_PRODUCT_VARIA_RCT715 ((FIT_GARMIN_PRODUCT)3808) +#define FIT_GARMIN_PRODUCT_LILY_ASIA ((FIT_GARMIN_PRODUCT)3809) +#define FIT_GARMIN_PRODUCT_EDGE_1030_PLUS_ASIA ((FIT_GARMIN_PRODUCT)3812) +#define FIT_GARMIN_PRODUCT_EDGE_130_PLUS_ASIA ((FIT_GARMIN_PRODUCT)3813) +#define FIT_GARMIN_PRODUCT_APPROACH_S12 ((FIT_GARMIN_PRODUCT)3823) +#define FIT_GARMIN_PRODUCT_ENDURO_ASIA ((FIT_GARMIN_PRODUCT)3872) +#define FIT_GARMIN_PRODUCT_VENUSQ_ASIA ((FIT_GARMIN_PRODUCT)3837) +#define FIT_GARMIN_PRODUCT_EDGE_1040 ((FIT_GARMIN_PRODUCT)3843) +#define FIT_GARMIN_PRODUCT_MARQ_GOLFER_ASIA ((FIT_GARMIN_PRODUCT)3850) +#define FIT_GARMIN_PRODUCT_VENU2_PLUS ((FIT_GARMIN_PRODUCT)3851) +#define FIT_GARMIN_PRODUCT_GNSS ((FIT_GARMIN_PRODUCT)3865) // Airoha AG3335M Family +#define FIT_GARMIN_PRODUCT_FR55 ((FIT_GARMIN_PRODUCT)3869) +#define FIT_GARMIN_PRODUCT_INSTINCT_2 ((FIT_GARMIN_PRODUCT)3888) +#define FIT_GARMIN_PRODUCT_INSTINCT_2S ((FIT_GARMIN_PRODUCT)3889) +#define FIT_GARMIN_PRODUCT_FENIX7S ((FIT_GARMIN_PRODUCT)3905) +#define FIT_GARMIN_PRODUCT_FENIX7 ((FIT_GARMIN_PRODUCT)3906) +#define FIT_GARMIN_PRODUCT_FENIX7X ((FIT_GARMIN_PRODUCT)3907) +#define FIT_GARMIN_PRODUCT_FENIX7S_APAC ((FIT_GARMIN_PRODUCT)3908) +#define FIT_GARMIN_PRODUCT_FENIX7_APAC ((FIT_GARMIN_PRODUCT)3909) +#define FIT_GARMIN_PRODUCT_FENIX7X_APAC ((FIT_GARMIN_PRODUCT)3910) +#define FIT_GARMIN_PRODUCT_APPROACH_G12 ((FIT_GARMIN_PRODUCT) 3927) +#define FIT_GARMIN_PRODUCT_DESCENT_MK2S_ASIA ((FIT_GARMIN_PRODUCT)3930) +#define FIT_GARMIN_PRODUCT_APPROACH_S42 ((FIT_GARMIN_PRODUCT)3934) +#define FIT_GARMIN_PRODUCT_EPIX_GEN2 ((FIT_GARMIN_PRODUCT)3943) +#define FIT_GARMIN_PRODUCT_EPIX_GEN2_APAC ((FIT_GARMIN_PRODUCT)3944) +#define FIT_GARMIN_PRODUCT_VENU2S_ASIA ((FIT_GARMIN_PRODUCT)3949) +#define FIT_GARMIN_PRODUCT_VENU2_ASIA ((FIT_GARMIN_PRODUCT)3950) +#define FIT_GARMIN_PRODUCT_FR945_LTE_ASIA ((FIT_GARMIN_PRODUCT)3978) +#define FIT_GARMIN_PRODUCT_VIVO_MOVE_SPORT ((FIT_GARMIN_PRODUCT)3982) +#define FIT_GARMIN_PRODUCT_VIVOMOVE_TREND ((FIT_GARMIN_PRODUCT)3983) +#define FIT_GARMIN_PRODUCT_APPROACH_S12_ASIA ((FIT_GARMIN_PRODUCT)3986) +#define FIT_GARMIN_PRODUCT_FR255_MUSIC ((FIT_GARMIN_PRODUCT)3990) +#define FIT_GARMIN_PRODUCT_FR255_SMALL_MUSIC ((FIT_GARMIN_PRODUCT)3991) +#define FIT_GARMIN_PRODUCT_FR255 ((FIT_GARMIN_PRODUCT)3992) +#define FIT_GARMIN_PRODUCT_FR255_SMALL ((FIT_GARMIN_PRODUCT)3993) +#define FIT_GARMIN_PRODUCT_APPROACH_G12_ASIA ((FIT_GARMIN_PRODUCT) 4001) +#define FIT_GARMIN_PRODUCT_APPROACH_S42_ASIA ((FIT_GARMIN_PRODUCT)4002) +#define FIT_GARMIN_PRODUCT_DESCENT_G1 ((FIT_GARMIN_PRODUCT)4005) +#define FIT_GARMIN_PRODUCT_VENU2_PLUS_ASIA ((FIT_GARMIN_PRODUCT)4017) +#define FIT_GARMIN_PRODUCT_FR955 ((FIT_GARMIN_PRODUCT)4024) +#define FIT_GARMIN_PRODUCT_FR55_ASIA ((FIT_GARMIN_PRODUCT)4033) +#define FIT_GARMIN_PRODUCT_EDGE_540 ((FIT_GARMIN_PRODUCT)4061) +#define FIT_GARMIN_PRODUCT_EDGE_840 ((FIT_GARMIN_PRODUCT)4062) +#define FIT_GARMIN_PRODUCT_VIVOSMART_5 ((FIT_GARMIN_PRODUCT)4063) +#define FIT_GARMIN_PRODUCT_INSTINCT_2_ASIA ((FIT_GARMIN_PRODUCT)4071) +#define FIT_GARMIN_PRODUCT_MARQ_GEN2 ((FIT_GARMIN_PRODUCT)4105) // Adventurer, Athlete, Captain, Golfer +#define FIT_GARMIN_PRODUCT_VENUSQ2 ((FIT_GARMIN_PRODUCT)4115) +#define FIT_GARMIN_PRODUCT_VENUSQ2MUSIC ((FIT_GARMIN_PRODUCT)4116) +#define FIT_GARMIN_PRODUCT_MARQ_GEN2_AVIATOR ((FIT_GARMIN_PRODUCT)4124) +#define FIT_GARMIN_PRODUCT_D2_AIR_X10 ((FIT_GARMIN_PRODUCT)4125) +#define FIT_GARMIN_PRODUCT_HRM_PRO_PLUS ((FIT_GARMIN_PRODUCT)4130) +#define FIT_GARMIN_PRODUCT_DESCENT_G1_ASIA ((FIT_GARMIN_PRODUCT)4132) +#define FIT_GARMIN_PRODUCT_TACTIX7 ((FIT_GARMIN_PRODUCT)4135) +#define FIT_GARMIN_PRODUCT_INSTINCT_CROSSOVER ((FIT_GARMIN_PRODUCT)4155) +#define FIT_GARMIN_PRODUCT_EDGE_EXPLORE2 ((FIT_GARMIN_PRODUCT)4169) +#define FIT_GARMIN_PRODUCT_DESCENT_MK3 ((FIT_GARMIN_PRODUCT)4222) +#define FIT_GARMIN_PRODUCT_DESCENT_MK3I ((FIT_GARMIN_PRODUCT)4223) +#define FIT_GARMIN_PRODUCT_APPROACH_S70 ((FIT_GARMIN_PRODUCT)4233) +#define FIT_GARMIN_PRODUCT_FR265_LARGE ((FIT_GARMIN_PRODUCT)4257) +#define FIT_GARMIN_PRODUCT_FR265_SMALL ((FIT_GARMIN_PRODUCT)4258) +#define FIT_GARMIN_PRODUCT_VENU3 ((FIT_GARMIN_PRODUCT)4260) +#define FIT_GARMIN_PRODUCT_VENU3S ((FIT_GARMIN_PRODUCT)4261) +#define FIT_GARMIN_PRODUCT_TACX_NEO_SMART ((FIT_GARMIN_PRODUCT)4265) // Neo Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_NEO2_SMART ((FIT_GARMIN_PRODUCT)4266) // Neo 2 Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_NEO2_T_SMART ((FIT_GARMIN_PRODUCT)4267) // Neo 2T Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_NEO_SMART_BIKE ((FIT_GARMIN_PRODUCT)4268) // Neo Smart Bike, Tacx +#define FIT_GARMIN_PRODUCT_TACX_SATORI_SMART ((FIT_GARMIN_PRODUCT)4269) // Satori Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_FLOW_SMART ((FIT_GARMIN_PRODUCT)4270) // Flow Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_VORTEX_SMART ((FIT_GARMIN_PRODUCT)4271) // Vortex Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_BUSHIDO_SMART ((FIT_GARMIN_PRODUCT)4272) // Bushido Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_GENIUS_SMART ((FIT_GARMIN_PRODUCT)4273) // Genius Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_FLUX_FLUX_S_SMART ((FIT_GARMIN_PRODUCT)4274) // Flux/Flux S Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_FLUX2_SMART ((FIT_GARMIN_PRODUCT)4275) // Flux 2 Smart, Tacx +#define FIT_GARMIN_PRODUCT_TACX_MAGNUM ((FIT_GARMIN_PRODUCT)4276) // Magnum, Tacx +#define FIT_GARMIN_PRODUCT_EDGE_1040_ASIA ((FIT_GARMIN_PRODUCT)4305) +#define FIT_GARMIN_PRODUCT_EPIX_GEN2_PRO_42 ((FIT_GARMIN_PRODUCT)4312) +#define FIT_GARMIN_PRODUCT_EPIX_GEN2_PRO_47 ((FIT_GARMIN_PRODUCT)4313) +#define FIT_GARMIN_PRODUCT_EPIX_GEN2_PRO_51 ((FIT_GARMIN_PRODUCT)4314) +#define FIT_GARMIN_PRODUCT_FR965 ((FIT_GARMIN_PRODUCT)4315) +#define FIT_GARMIN_PRODUCT_ENDURO2 ((FIT_GARMIN_PRODUCT)4341) +#define FIT_GARMIN_PRODUCT_FENIX7S_PRO_SOLAR ((FIT_GARMIN_PRODUCT)4374) +#define FIT_GARMIN_PRODUCT_FENIX7_PRO_SOLAR ((FIT_GARMIN_PRODUCT)4375) +#define FIT_GARMIN_PRODUCT_FENIX7X_PRO_SOLAR ((FIT_GARMIN_PRODUCT)4376) +#define FIT_GARMIN_PRODUCT_LILY2 ((FIT_GARMIN_PRODUCT)4380) +#define FIT_GARMIN_PRODUCT_INSTINCT_2X ((FIT_GARMIN_PRODUCT)4394) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE5 ((FIT_GARMIN_PRODUCT)4426) +#define FIT_GARMIN_PRODUCT_FR165 ((FIT_GARMIN_PRODUCT)4432) +#define FIT_GARMIN_PRODUCT_FR165_MUSIC ((FIT_GARMIN_PRODUCT)4433) +#define FIT_GARMIN_PRODUCT_EDGE_1050 ((FIT_GARMIN_PRODUCT)4440) +#define FIT_GARMIN_PRODUCT_DESCENT_T2 ((FIT_GARMIN_PRODUCT)4442) +#define FIT_GARMIN_PRODUCT_HRM_FIT ((FIT_GARMIN_PRODUCT)4446) +#define FIT_GARMIN_PRODUCT_MARQ_GEN2_COMMANDER ((FIT_GARMIN_PRODUCT)4472) +#define FIT_GARMIN_PRODUCT_LILY_ATHLETE ((FIT_GARMIN_PRODUCT)4477) // aka the Lily 2 Active +#define FIT_GARMIN_PRODUCT_RALLY_X10 ((FIT_GARMIN_PRODUCT)4525) // Rally 110/210 +#define FIT_GARMIN_PRODUCT_FENIX8_SOLAR ((FIT_GARMIN_PRODUCT)4532) +#define FIT_GARMIN_PRODUCT_FENIX8_SOLAR_LARGE ((FIT_GARMIN_PRODUCT)4533) +#define FIT_GARMIN_PRODUCT_FENIX8_SMALL ((FIT_GARMIN_PRODUCT)4534) +#define FIT_GARMIN_PRODUCT_FENIX8 ((FIT_GARMIN_PRODUCT)4536) +#define FIT_GARMIN_PRODUCT_D2_MACH1_PRO ((FIT_GARMIN_PRODUCT)4556) +#define FIT_GARMIN_PRODUCT_ENDURO3 ((FIT_GARMIN_PRODUCT)4575) +#define FIT_GARMIN_PRODUCT_INSTINCTE_40MM ((FIT_GARMIN_PRODUCT)4583) +#define FIT_GARMIN_PRODUCT_INSTINCTE_45MM ((FIT_GARMIN_PRODUCT)4584) +#define FIT_GARMIN_PRODUCT_INSTINCT3_SOLAR_45MM ((FIT_GARMIN_PRODUCT)4585) +#define FIT_GARMIN_PRODUCT_INSTINCT3_AMOLED_45MM ((FIT_GARMIN_PRODUCT)4586) +#define FIT_GARMIN_PRODUCT_INSTINCT3_AMOLED_50MM ((FIT_GARMIN_PRODUCT)4587) +#define FIT_GARMIN_PRODUCT_DESCENT_G2 ((FIT_GARMIN_PRODUCT)4588) +#define FIT_GARMIN_PRODUCT_VENU_X1 ((FIT_GARMIN_PRODUCT)4603) +#define FIT_GARMIN_PRODUCT_HRM_200 ((FIT_GARMIN_PRODUCT)4606) +#define FIT_GARMIN_PRODUCT_VIVOACTIVE6 ((FIT_GARMIN_PRODUCT)4625) +#define FIT_GARMIN_PRODUCT_FENIX8_PRO ((FIT_GARMIN_PRODUCT)4631) +#define FIT_GARMIN_PRODUCT_EDGE_550 ((FIT_GARMIN_PRODUCT)4633) +#define FIT_GARMIN_PRODUCT_EDGE_850 ((FIT_GARMIN_PRODUCT)4634) +#define FIT_GARMIN_PRODUCT_VENU4 ((FIT_GARMIN_PRODUCT)4643) +#define FIT_GARMIN_PRODUCT_VENU4S ((FIT_GARMIN_PRODUCT)4644) +#define FIT_GARMIN_PRODUCT_APPROACHS44 ((FIT_GARMIN_PRODUCT)4647) +#define FIT_GARMIN_PRODUCT_EDGE_MTB ((FIT_GARMIN_PRODUCT)4655) +#define FIT_GARMIN_PRODUCT_APPROACHS50 ((FIT_GARMIN_PRODUCT)4656) +#define FIT_GARMIN_PRODUCT_FENIX_E ((FIT_GARMIN_PRODUCT)4666) +#define FIT_GARMIN_PRODUCT_BOUNCE2 ((FIT_GARMIN_PRODUCT)4745) +#define FIT_GARMIN_PRODUCT_INSTINCT3_SOLAR_50MM ((FIT_GARMIN_PRODUCT)4759) +#define FIT_GARMIN_PRODUCT_TACTIX8_AMOLED ((FIT_GARMIN_PRODUCT)4775) +#define FIT_GARMIN_PRODUCT_TACTIX8_SOLAR ((FIT_GARMIN_PRODUCT)4776) +#define FIT_GARMIN_PRODUCT_D2_MACH2 ((FIT_GARMIN_PRODUCT)4879) +#define FIT_GARMIN_PRODUCT_INSTINCT_CROSSOVER_AMOLED ((FIT_GARMIN_PRODUCT)4678) +#define FIT_GARMIN_PRODUCT_D2_AIR_X15 ((FIT_GARMIN_PRODUCT)4944) +#define FIT_GARMIN_PRODUCT_SDM4 ((FIT_GARMIN_PRODUCT)10007) // SDM4 footpod +#define FIT_GARMIN_PRODUCT_EDGE_REMOTE ((FIT_GARMIN_PRODUCT)10014) +#define FIT_GARMIN_PRODUCT_TACX_TRAINING_APP_WIN ((FIT_GARMIN_PRODUCT)20533) +#define FIT_GARMIN_PRODUCT_TACX_TRAINING_APP_MAC ((FIT_GARMIN_PRODUCT)20534) +#define FIT_GARMIN_PRODUCT_TACX_TRAINING_APP_MAC_CATALYST ((FIT_GARMIN_PRODUCT)20565) +#define FIT_GARMIN_PRODUCT_TRAINING_CENTER ((FIT_GARMIN_PRODUCT)20119) +#define FIT_GARMIN_PRODUCT_TACX_TRAINING_APP_ANDROID ((FIT_GARMIN_PRODUCT)30045) +#define FIT_GARMIN_PRODUCT_TACX_TRAINING_APP_IOS ((FIT_GARMIN_PRODUCT)30046) +#define FIT_GARMIN_PRODUCT_TACX_TRAINING_APP_LEGACY ((FIT_GARMIN_PRODUCT)30047) +#define FIT_GARMIN_PRODUCT_CONNECTIQ_SIMULATOR ((FIT_GARMIN_PRODUCT)65531) +#define FIT_GARMIN_PRODUCT_ANDROID_ANTPLUS_PLUGIN ((FIT_GARMIN_PRODUCT)65532) +#define FIT_GARMIN_PRODUCT_CONNECT ((FIT_GARMIN_PRODUCT)65534) // Garmin Connect website +#define FIT_GARMIN_PRODUCT_COUNT 474 + +typedef FIT_UINT8 FIT_ANTPLUS_DEVICE_TYPE; +#define FIT_ANTPLUS_DEVICE_TYPE_INVALID FIT_UINT8_INVALID +#define FIT_ANTPLUS_DEVICE_TYPE_ANTFS ((FIT_ANTPLUS_DEVICE_TYPE)1) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_POWER ((FIT_ANTPLUS_DEVICE_TYPE)11) +#define FIT_ANTPLUS_DEVICE_TYPE_ENVIRONMENT_SENSOR_LEGACY ((FIT_ANTPLUS_DEVICE_TYPE)12) +#define FIT_ANTPLUS_DEVICE_TYPE_MULTI_SPORT_SPEED_DISTANCE ((FIT_ANTPLUS_DEVICE_TYPE)15) +#define FIT_ANTPLUS_DEVICE_TYPE_CONTROL ((FIT_ANTPLUS_DEVICE_TYPE)16) +#define FIT_ANTPLUS_DEVICE_TYPE_FITNESS_EQUIPMENT ((FIT_ANTPLUS_DEVICE_TYPE)17) +#define FIT_ANTPLUS_DEVICE_TYPE_BLOOD_PRESSURE ((FIT_ANTPLUS_DEVICE_TYPE)18) +#define FIT_ANTPLUS_DEVICE_TYPE_GEOCACHE_NODE ((FIT_ANTPLUS_DEVICE_TYPE)19) +#define FIT_ANTPLUS_DEVICE_TYPE_LIGHT_ELECTRIC_VEHICLE ((FIT_ANTPLUS_DEVICE_TYPE)20) +#define FIT_ANTPLUS_DEVICE_TYPE_ENV_SENSOR ((FIT_ANTPLUS_DEVICE_TYPE)25) +#define FIT_ANTPLUS_DEVICE_TYPE_RACQUET ((FIT_ANTPLUS_DEVICE_TYPE)26) +#define FIT_ANTPLUS_DEVICE_TYPE_CONTROL_HUB ((FIT_ANTPLUS_DEVICE_TYPE)27) +#define FIT_ANTPLUS_DEVICE_TYPE_MUSCLE_OXYGEN ((FIT_ANTPLUS_DEVICE_TYPE)31) +#define FIT_ANTPLUS_DEVICE_TYPE_SHIFTING ((FIT_ANTPLUS_DEVICE_TYPE)34) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_LIGHT_MAIN ((FIT_ANTPLUS_DEVICE_TYPE)35) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_LIGHT_SHARED ((FIT_ANTPLUS_DEVICE_TYPE)36) +#define FIT_ANTPLUS_DEVICE_TYPE_EXD ((FIT_ANTPLUS_DEVICE_TYPE)38) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_RADAR ((FIT_ANTPLUS_DEVICE_TYPE)40) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_AERO ((FIT_ANTPLUS_DEVICE_TYPE)46) +#define FIT_ANTPLUS_DEVICE_TYPE_WEIGHT_SCALE ((FIT_ANTPLUS_DEVICE_TYPE)119) +#define FIT_ANTPLUS_DEVICE_TYPE_HEART_RATE ((FIT_ANTPLUS_DEVICE_TYPE)120) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_SPEED_CADENCE ((FIT_ANTPLUS_DEVICE_TYPE)121) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_CADENCE ((FIT_ANTPLUS_DEVICE_TYPE)122) +#define FIT_ANTPLUS_DEVICE_TYPE_BIKE_SPEED ((FIT_ANTPLUS_DEVICE_TYPE)123) +#define FIT_ANTPLUS_DEVICE_TYPE_STRIDE_SPEED_DISTANCE ((FIT_ANTPLUS_DEVICE_TYPE)124) +#define FIT_ANTPLUS_DEVICE_TYPE_COUNT 25 + +typedef FIT_ENUM FIT_ANT_NETWORK; +#define FIT_ANT_NETWORK_INVALID FIT_ENUM_INVALID +#define FIT_ANT_NETWORK_PUBLIC ((FIT_ANT_NETWORK)0) +#define FIT_ANT_NETWORK_ANTPLUS ((FIT_ANT_NETWORK)1) +#define FIT_ANT_NETWORK_ANTFS ((FIT_ANT_NETWORK)2) +#define FIT_ANT_NETWORK_PRIVATE ((FIT_ANT_NETWORK)3) +#define FIT_ANT_NETWORK_COUNT 4 + +typedef FIT_UINT32Z FIT_WORKOUT_CAPABILITIES; +#define FIT_WORKOUT_CAPABILITIES_INVALID FIT_UINT32Z_INVALID +#define FIT_WORKOUT_CAPABILITIES_INTERVAL ((FIT_WORKOUT_CAPABILITIES)0x00000001) +#define FIT_WORKOUT_CAPABILITIES_CUSTOM ((FIT_WORKOUT_CAPABILITIES)0x00000002) +#define FIT_WORKOUT_CAPABILITIES_FITNESS_EQUIPMENT ((FIT_WORKOUT_CAPABILITIES)0x00000004) +#define FIT_WORKOUT_CAPABILITIES_FIRSTBEAT ((FIT_WORKOUT_CAPABILITIES)0x00000008) +#define FIT_WORKOUT_CAPABILITIES_NEW_LEAF ((FIT_WORKOUT_CAPABILITIES)0x00000010) +#define FIT_WORKOUT_CAPABILITIES_TCX ((FIT_WORKOUT_CAPABILITIES)0x00000020) // For backwards compatibility. Watch should add missing id fields then clear flag. +#define FIT_WORKOUT_CAPABILITIES_SPEED ((FIT_WORKOUT_CAPABILITIES)0x00000080) // Speed source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_HEART_RATE ((FIT_WORKOUT_CAPABILITIES)0x00000100) // Heart rate source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_DISTANCE ((FIT_WORKOUT_CAPABILITIES)0x00000200) // Distance source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_CADENCE ((FIT_WORKOUT_CAPABILITIES)0x00000400) // Cadence source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_POWER ((FIT_WORKOUT_CAPABILITIES)0x00000800) // Power source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_GRADE ((FIT_WORKOUT_CAPABILITIES)0x00001000) // Grade source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_RESISTANCE ((FIT_WORKOUT_CAPABILITIES)0x00002000) // Resistance source required for workout step. +#define FIT_WORKOUT_CAPABILITIES_PROTECTED ((FIT_WORKOUT_CAPABILITIES)0x00004000) +#define FIT_WORKOUT_CAPABILITIES_COUNT 14 + +typedef FIT_UINT8 FIT_BATTERY_STATUS; +#define FIT_BATTERY_STATUS_INVALID FIT_UINT8_INVALID +#define FIT_BATTERY_STATUS_NEW ((FIT_BATTERY_STATUS)1) +#define FIT_BATTERY_STATUS_GOOD ((FIT_BATTERY_STATUS)2) +#define FIT_BATTERY_STATUS_OK ((FIT_BATTERY_STATUS)3) +#define FIT_BATTERY_STATUS_LOW ((FIT_BATTERY_STATUS)4) +#define FIT_BATTERY_STATUS_CRITICAL ((FIT_BATTERY_STATUS)5) +#define FIT_BATTERY_STATUS_CHARGING ((FIT_BATTERY_STATUS)6) +#define FIT_BATTERY_STATUS_UNKNOWN ((FIT_BATTERY_STATUS)7) +#define FIT_BATTERY_STATUS_COUNT 7 + +typedef FIT_ENUM FIT_HR_TYPE; +#define FIT_HR_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_HR_TYPE_NORMAL ((FIT_HR_TYPE)0) +#define FIT_HR_TYPE_IRREGULAR ((FIT_HR_TYPE)1) +#define FIT_HR_TYPE_COUNT 2 + +typedef FIT_UINT32Z FIT_COURSE_CAPABILITIES; +#define FIT_COURSE_CAPABILITIES_INVALID FIT_UINT32Z_INVALID +#define FIT_COURSE_CAPABILITIES_PROCESSED ((FIT_COURSE_CAPABILITIES)0x00000001) +#define FIT_COURSE_CAPABILITIES_VALID ((FIT_COURSE_CAPABILITIES)0x00000002) +#define FIT_COURSE_CAPABILITIES_TIME ((FIT_COURSE_CAPABILITIES)0x00000004) +#define FIT_COURSE_CAPABILITIES_DISTANCE ((FIT_COURSE_CAPABILITIES)0x00000008) +#define FIT_COURSE_CAPABILITIES_POSITION ((FIT_COURSE_CAPABILITIES)0x00000010) +#define FIT_COURSE_CAPABILITIES_HEART_RATE ((FIT_COURSE_CAPABILITIES)0x00000020) +#define FIT_COURSE_CAPABILITIES_POWER ((FIT_COURSE_CAPABILITIES)0x00000040) +#define FIT_COURSE_CAPABILITIES_CADENCE ((FIT_COURSE_CAPABILITIES)0x00000080) +#define FIT_COURSE_CAPABILITIES_TRAINING ((FIT_COURSE_CAPABILITIES)0x00000100) +#define FIT_COURSE_CAPABILITIES_NAVIGATION ((FIT_COURSE_CAPABILITIES)0x00000200) +#define FIT_COURSE_CAPABILITIES_BIKEWAY ((FIT_COURSE_CAPABILITIES)0x00000400) +#define FIT_COURSE_CAPABILITIES_AVIATION ((FIT_COURSE_CAPABILITIES)0x00001000) // Denote course files to be used as flight plans +#define FIT_COURSE_CAPABILITIES_COUNT 12 + +typedef FIT_UINT16 FIT_WEIGHT; +#define FIT_WEIGHT_INVALID FIT_UINT16_INVALID +#define FIT_WEIGHT_CALCULATING ((FIT_WEIGHT)0xFFFE) +#define FIT_WEIGHT_COUNT 1 + +typedef FIT_UINT32 FIT_WORKOUT_HR; // 0 - 100 indicates% of max hr; >100 indicates bpm (255 max) plus 100 +#define FIT_WORKOUT_HR_INVALID FIT_UINT32_INVALID +#define FIT_WORKOUT_HR_BPM_OFFSET ((FIT_WORKOUT_HR)100) +#define FIT_WORKOUT_HR_COUNT 1 + +typedef FIT_UINT32 FIT_WORKOUT_POWER; // 0 - 1000 indicates % of functional threshold power; >1000 indicates watts plus 1000. +#define FIT_WORKOUT_POWER_INVALID FIT_UINT32_INVALID +#define FIT_WORKOUT_POWER_WATTS_OFFSET ((FIT_WORKOUT_POWER)1000) +#define FIT_WORKOUT_POWER_COUNT 1 + +typedef FIT_ENUM FIT_BP_STATUS; +#define FIT_BP_STATUS_INVALID FIT_ENUM_INVALID +#define FIT_BP_STATUS_NO_ERROR ((FIT_BP_STATUS)0) +#define FIT_BP_STATUS_ERROR_INCOMPLETE_DATA ((FIT_BP_STATUS)1) +#define FIT_BP_STATUS_ERROR_NO_MEASUREMENT ((FIT_BP_STATUS)2) +#define FIT_BP_STATUS_ERROR_DATA_OUT_OF_RANGE ((FIT_BP_STATUS)3) +#define FIT_BP_STATUS_ERROR_IRREGULAR_HEART_RATE ((FIT_BP_STATUS)4) +#define FIT_BP_STATUS_COUNT 5 + +typedef FIT_UINT16 FIT_USER_LOCAL_ID; +#define FIT_USER_LOCAL_ID_INVALID FIT_UINT16_INVALID +#define FIT_USER_LOCAL_ID_LOCAL_MIN ((FIT_USER_LOCAL_ID)0x0000) +#define FIT_USER_LOCAL_ID_LOCAL_MAX ((FIT_USER_LOCAL_ID)0x000F) +#define FIT_USER_LOCAL_ID_STATIONARY_MIN ((FIT_USER_LOCAL_ID)0x0010) +#define FIT_USER_LOCAL_ID_STATIONARY_MAX ((FIT_USER_LOCAL_ID)0x00FF) +#define FIT_USER_LOCAL_ID_PORTABLE_MIN ((FIT_USER_LOCAL_ID)0x0100) +#define FIT_USER_LOCAL_ID_PORTABLE_MAX ((FIT_USER_LOCAL_ID)0xFFFE) +#define FIT_USER_LOCAL_ID_COUNT 6 + +typedef FIT_ENUM FIT_SWIM_STROKE; +#define FIT_SWIM_STROKE_INVALID FIT_ENUM_INVALID +#define FIT_SWIM_STROKE_FREESTYLE ((FIT_SWIM_STROKE)0) +#define FIT_SWIM_STROKE_BACKSTROKE ((FIT_SWIM_STROKE)1) +#define FIT_SWIM_STROKE_BREASTSTROKE ((FIT_SWIM_STROKE)2) +#define FIT_SWIM_STROKE_BUTTERFLY ((FIT_SWIM_STROKE)3) +#define FIT_SWIM_STROKE_DRILL ((FIT_SWIM_STROKE)4) +#define FIT_SWIM_STROKE_MIXED ((FIT_SWIM_STROKE)5) +#define FIT_SWIM_STROKE_IM ((FIT_SWIM_STROKE)6) // IM is a mixed interval containing the same number of lengths for each of: Butterfly, Backstroke, Breaststroke, Freestyle, swam in that order. +#define FIT_SWIM_STROKE_IM_BY_ROUND ((FIT_SWIM_STROKE)7) // For repeated workout steps, a new individual medly stroke is used for each round. +#define FIT_SWIM_STROKE_RIMO ((FIT_SWIM_STROKE)8) // Reverse IM Order +#define FIT_SWIM_STROKE_COUNT 9 + +typedef FIT_ENUM FIT_ACTIVITY_TYPE; +#define FIT_ACTIVITY_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_ACTIVITY_TYPE_GENERIC ((FIT_ACTIVITY_TYPE)0) +#define FIT_ACTIVITY_TYPE_RUNNING ((FIT_ACTIVITY_TYPE)1) +#define FIT_ACTIVITY_TYPE_CYCLING ((FIT_ACTIVITY_TYPE)2) +#define FIT_ACTIVITY_TYPE_TRANSITION ((FIT_ACTIVITY_TYPE)3) // Mulitsport transition +#define FIT_ACTIVITY_TYPE_FITNESS_EQUIPMENT ((FIT_ACTIVITY_TYPE)4) +#define FIT_ACTIVITY_TYPE_SWIMMING ((FIT_ACTIVITY_TYPE)5) +#define FIT_ACTIVITY_TYPE_WALKING ((FIT_ACTIVITY_TYPE)6) +#define FIT_ACTIVITY_TYPE_SEDENTARY ((FIT_ACTIVITY_TYPE)8) +#define FIT_ACTIVITY_TYPE_ALL ((FIT_ACTIVITY_TYPE)254) // All is for goals only to include all sports. +#define FIT_ACTIVITY_TYPE_COUNT 9 + +typedef FIT_ENUM FIT_ACTIVITY_SUBTYPE; +#define FIT_ACTIVITY_SUBTYPE_INVALID FIT_ENUM_INVALID +#define FIT_ACTIVITY_SUBTYPE_GENERIC ((FIT_ACTIVITY_SUBTYPE)0) +#define FIT_ACTIVITY_SUBTYPE_TREADMILL ((FIT_ACTIVITY_SUBTYPE)1) // Run +#define FIT_ACTIVITY_SUBTYPE_STREET ((FIT_ACTIVITY_SUBTYPE)2) // Run +#define FIT_ACTIVITY_SUBTYPE_TRAIL ((FIT_ACTIVITY_SUBTYPE)3) // Run +#define FIT_ACTIVITY_SUBTYPE_TRACK ((FIT_ACTIVITY_SUBTYPE)4) // Run +#define FIT_ACTIVITY_SUBTYPE_SPIN ((FIT_ACTIVITY_SUBTYPE)5) // Cycling +#define FIT_ACTIVITY_SUBTYPE_INDOOR_CYCLING ((FIT_ACTIVITY_SUBTYPE)6) // Cycling +#define FIT_ACTIVITY_SUBTYPE_ROAD ((FIT_ACTIVITY_SUBTYPE)7) // Cycling +#define FIT_ACTIVITY_SUBTYPE_MOUNTAIN ((FIT_ACTIVITY_SUBTYPE)8) // Cycling +#define FIT_ACTIVITY_SUBTYPE_DOWNHILL ((FIT_ACTIVITY_SUBTYPE)9) // Cycling +#define FIT_ACTIVITY_SUBTYPE_RECUMBENT ((FIT_ACTIVITY_SUBTYPE)10) // Cycling +#define FIT_ACTIVITY_SUBTYPE_CYCLOCROSS ((FIT_ACTIVITY_SUBTYPE)11) // Cycling +#define FIT_ACTIVITY_SUBTYPE_HAND_CYCLING ((FIT_ACTIVITY_SUBTYPE)12) // Cycling +#define FIT_ACTIVITY_SUBTYPE_TRACK_CYCLING ((FIT_ACTIVITY_SUBTYPE)13) // Cycling +#define FIT_ACTIVITY_SUBTYPE_INDOOR_ROWING ((FIT_ACTIVITY_SUBTYPE)14) // Fitness Equipment +#define FIT_ACTIVITY_SUBTYPE_ELLIPTICAL ((FIT_ACTIVITY_SUBTYPE)15) // Fitness Equipment +#define FIT_ACTIVITY_SUBTYPE_STAIR_CLIMBING ((FIT_ACTIVITY_SUBTYPE)16) // Fitness Equipment +#define FIT_ACTIVITY_SUBTYPE_LAP_SWIMMING ((FIT_ACTIVITY_SUBTYPE)17) // Swimming +#define FIT_ACTIVITY_SUBTYPE_OPEN_WATER ((FIT_ACTIVITY_SUBTYPE)18) // Swimming +#define FIT_ACTIVITY_SUBTYPE_ALL ((FIT_ACTIVITY_SUBTYPE)254) +#define FIT_ACTIVITY_SUBTYPE_COUNT 20 + +typedef FIT_ENUM FIT_ACTIVITY_LEVEL; +#define FIT_ACTIVITY_LEVEL_INVALID FIT_ENUM_INVALID +#define FIT_ACTIVITY_LEVEL_LOW ((FIT_ACTIVITY_LEVEL)0) +#define FIT_ACTIVITY_LEVEL_MEDIUM ((FIT_ACTIVITY_LEVEL)1) +#define FIT_ACTIVITY_LEVEL_HIGH ((FIT_ACTIVITY_LEVEL)2) +#define FIT_ACTIVITY_LEVEL_COUNT 3 + +typedef FIT_ENUM FIT_SIDE; +#define FIT_SIDE_INVALID FIT_ENUM_INVALID +#define FIT_SIDE_RIGHT ((FIT_SIDE)0) +#define FIT_SIDE_LEFT ((FIT_SIDE)1) +#define FIT_SIDE_COUNT 2 + +typedef FIT_UINT8 FIT_LEFT_RIGHT_BALANCE; +#define FIT_LEFT_RIGHT_BALANCE_INVALID FIT_UINT8_INVALID +#define FIT_LEFT_RIGHT_BALANCE_MASK ((FIT_LEFT_RIGHT_BALANCE)0x7F) // % contribution +#define FIT_LEFT_RIGHT_BALANCE_RIGHT ((FIT_LEFT_RIGHT_BALANCE)0x80) // data corresponds to right if set, otherwise unknown +#define FIT_LEFT_RIGHT_BALANCE_COUNT 2 + +typedef FIT_UINT16 FIT_LEFT_RIGHT_BALANCE_100; +#define FIT_LEFT_RIGHT_BALANCE_100_INVALID FIT_UINT16_INVALID +#define FIT_LEFT_RIGHT_BALANCE_100_MASK ((FIT_LEFT_RIGHT_BALANCE_100)0x3FFF) // % contribution scaled by 100 +#define FIT_LEFT_RIGHT_BALANCE_100_RIGHT ((FIT_LEFT_RIGHT_BALANCE_100)0x8000) // data corresponds to right if set, otherwise unknown +#define FIT_LEFT_RIGHT_BALANCE_100_COUNT 2 + +typedef FIT_ENUM FIT_LENGTH_TYPE; +#define FIT_LENGTH_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_LENGTH_TYPE_IDLE ((FIT_LENGTH_TYPE)0) // Rest period. Length with no strokes +#define FIT_LENGTH_TYPE_ACTIVE ((FIT_LENGTH_TYPE)1) // Length with strokes. +#define FIT_LENGTH_TYPE_COUNT 2 + +typedef FIT_ENUM FIT_DAY_OF_WEEK; +#define FIT_DAY_OF_WEEK_INVALID FIT_ENUM_INVALID +#define FIT_DAY_OF_WEEK_SUNDAY ((FIT_DAY_OF_WEEK)0) +#define FIT_DAY_OF_WEEK_MONDAY ((FIT_DAY_OF_WEEK)1) +#define FIT_DAY_OF_WEEK_TUESDAY ((FIT_DAY_OF_WEEK)2) +#define FIT_DAY_OF_WEEK_WEDNESDAY ((FIT_DAY_OF_WEEK)3) +#define FIT_DAY_OF_WEEK_THURSDAY ((FIT_DAY_OF_WEEK)4) +#define FIT_DAY_OF_WEEK_FRIDAY ((FIT_DAY_OF_WEEK)5) +#define FIT_DAY_OF_WEEK_SATURDAY ((FIT_DAY_OF_WEEK)6) +#define FIT_DAY_OF_WEEK_COUNT 7 + +typedef FIT_UINT32Z FIT_CONNECTIVITY_CAPABILITIES; +#define FIT_CONNECTIVITY_CAPABILITIES_INVALID FIT_UINT32Z_INVALID +#define FIT_CONNECTIVITY_CAPABILITIES_BLUETOOTH ((FIT_CONNECTIVITY_CAPABILITIES)0x00000001) +#define FIT_CONNECTIVITY_CAPABILITIES_BLUETOOTH_LE ((FIT_CONNECTIVITY_CAPABILITIES)0x00000002) +#define FIT_CONNECTIVITY_CAPABILITIES_ANT ((FIT_CONNECTIVITY_CAPABILITIES)0x00000004) +#define FIT_CONNECTIVITY_CAPABILITIES_ACTIVITY_UPLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00000008) +#define FIT_CONNECTIVITY_CAPABILITIES_COURSE_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00000010) +#define FIT_CONNECTIVITY_CAPABILITIES_WORKOUT_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00000020) +#define FIT_CONNECTIVITY_CAPABILITIES_LIVE_TRACK ((FIT_CONNECTIVITY_CAPABILITIES)0x00000040) +#define FIT_CONNECTIVITY_CAPABILITIES_WEATHER_CONDITIONS ((FIT_CONNECTIVITY_CAPABILITIES)0x00000080) +#define FIT_CONNECTIVITY_CAPABILITIES_WEATHER_ALERTS ((FIT_CONNECTIVITY_CAPABILITIES)0x00000100) +#define FIT_CONNECTIVITY_CAPABILITIES_GPS_EPHEMERIS_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00000200) +#define FIT_CONNECTIVITY_CAPABILITIES_EXPLICIT_ARCHIVE ((FIT_CONNECTIVITY_CAPABILITIES)0x00000400) +#define FIT_CONNECTIVITY_CAPABILITIES_SETUP_INCOMPLETE ((FIT_CONNECTIVITY_CAPABILITIES)0x00000800) +#define FIT_CONNECTIVITY_CAPABILITIES_CONTINUE_SYNC_AFTER_SOFTWARE_UPDATE ((FIT_CONNECTIVITY_CAPABILITIES)0x00001000) +#define FIT_CONNECTIVITY_CAPABILITIES_CONNECT_IQ_APP_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00002000) +#define FIT_CONNECTIVITY_CAPABILITIES_GOLF_COURSE_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00004000) +#define FIT_CONNECTIVITY_CAPABILITIES_DEVICE_INITIATES_SYNC ((FIT_CONNECTIVITY_CAPABILITIES)0x00008000) // Indicates device is in control of initiating all syncs +#define FIT_CONNECTIVITY_CAPABILITIES_CONNECT_IQ_WATCH_APP_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00010000) +#define FIT_CONNECTIVITY_CAPABILITIES_CONNECT_IQ_WIDGET_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00020000) +#define FIT_CONNECTIVITY_CAPABILITIES_CONNECT_IQ_WATCH_FACE_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00040000) +#define FIT_CONNECTIVITY_CAPABILITIES_CONNECT_IQ_DATA_FIELD_DOWNLOAD ((FIT_CONNECTIVITY_CAPABILITIES)0x00080000) +#define FIT_CONNECTIVITY_CAPABILITIES_CONNECT_IQ_APP_MANAGMENT ((FIT_CONNECTIVITY_CAPABILITIES)0x00100000) // Device supports delete and reorder of apps via GCM +#define FIT_CONNECTIVITY_CAPABILITIES_SWING_SENSOR ((FIT_CONNECTIVITY_CAPABILITIES)0x00200000) +#define FIT_CONNECTIVITY_CAPABILITIES_SWING_SENSOR_REMOTE ((FIT_CONNECTIVITY_CAPABILITIES)0x00400000) +#define FIT_CONNECTIVITY_CAPABILITIES_INCIDENT_DETECTION ((FIT_CONNECTIVITY_CAPABILITIES)0x00800000) // Device supports incident detection +#define FIT_CONNECTIVITY_CAPABILITIES_AUDIO_PROMPTS ((FIT_CONNECTIVITY_CAPABILITIES)0x01000000) +#define FIT_CONNECTIVITY_CAPABILITIES_WIFI_VERIFICATION ((FIT_CONNECTIVITY_CAPABILITIES)0x02000000) // Device supports reporting wifi verification via GCM +#define FIT_CONNECTIVITY_CAPABILITIES_TRUE_UP ((FIT_CONNECTIVITY_CAPABILITIES)0x04000000) // Device supports True Up +#define FIT_CONNECTIVITY_CAPABILITIES_FIND_MY_WATCH ((FIT_CONNECTIVITY_CAPABILITIES)0x08000000) // Device supports Find My Watch +#define FIT_CONNECTIVITY_CAPABILITIES_REMOTE_MANUAL_SYNC ((FIT_CONNECTIVITY_CAPABILITIES)0x10000000) +#define FIT_CONNECTIVITY_CAPABILITIES_LIVE_TRACK_AUTO_START ((FIT_CONNECTIVITY_CAPABILITIES)0x20000000) // Device supports LiveTrack auto start +#define FIT_CONNECTIVITY_CAPABILITIES_LIVE_TRACK_MESSAGING ((FIT_CONNECTIVITY_CAPABILITIES)0x40000000) // Device supports LiveTrack Messaging +#define FIT_CONNECTIVITY_CAPABILITIES_INSTANT_INPUT ((FIT_CONNECTIVITY_CAPABILITIES)0x80000000) // Device supports instant input feature +#define FIT_CONNECTIVITY_CAPABILITIES_COUNT 32 + +typedef FIT_ENUM FIT_WEATHER_REPORT; +#define FIT_WEATHER_REPORT_INVALID FIT_ENUM_INVALID +#define FIT_WEATHER_REPORT_CURRENT ((FIT_WEATHER_REPORT)0) +#define FIT_WEATHER_REPORT_FORECAST ((FIT_WEATHER_REPORT)1) // Deprecated use hourly_forecast instead +#define FIT_WEATHER_REPORT_HOURLY_FORECAST ((FIT_WEATHER_REPORT)1) +#define FIT_WEATHER_REPORT_DAILY_FORECAST ((FIT_WEATHER_REPORT)2) +#define FIT_WEATHER_REPORT_COUNT 4 + +typedef FIT_ENUM FIT_WEATHER_STATUS; +#define FIT_WEATHER_STATUS_INVALID FIT_ENUM_INVALID +#define FIT_WEATHER_STATUS_CLEAR ((FIT_WEATHER_STATUS)0) +#define FIT_WEATHER_STATUS_PARTLY_CLOUDY ((FIT_WEATHER_STATUS)1) +#define FIT_WEATHER_STATUS_MOSTLY_CLOUDY ((FIT_WEATHER_STATUS)2) +#define FIT_WEATHER_STATUS_RAIN ((FIT_WEATHER_STATUS)3) +#define FIT_WEATHER_STATUS_SNOW ((FIT_WEATHER_STATUS)4) +#define FIT_WEATHER_STATUS_WINDY ((FIT_WEATHER_STATUS)5) +#define FIT_WEATHER_STATUS_THUNDERSTORMS ((FIT_WEATHER_STATUS)6) +#define FIT_WEATHER_STATUS_WINTRY_MIX ((FIT_WEATHER_STATUS)7) +#define FIT_WEATHER_STATUS_FOG ((FIT_WEATHER_STATUS)8) +#define FIT_WEATHER_STATUS_HAZY ((FIT_WEATHER_STATUS)11) +#define FIT_WEATHER_STATUS_HAIL ((FIT_WEATHER_STATUS)12) +#define FIT_WEATHER_STATUS_SCATTERED_SHOWERS ((FIT_WEATHER_STATUS)13) +#define FIT_WEATHER_STATUS_SCATTERED_THUNDERSTORMS ((FIT_WEATHER_STATUS)14) +#define FIT_WEATHER_STATUS_UNKNOWN_PRECIPITATION ((FIT_WEATHER_STATUS)15) +#define FIT_WEATHER_STATUS_LIGHT_RAIN ((FIT_WEATHER_STATUS)16) +#define FIT_WEATHER_STATUS_HEAVY_RAIN ((FIT_WEATHER_STATUS)17) +#define FIT_WEATHER_STATUS_LIGHT_SNOW ((FIT_WEATHER_STATUS)18) +#define FIT_WEATHER_STATUS_HEAVY_SNOW ((FIT_WEATHER_STATUS)19) +#define FIT_WEATHER_STATUS_LIGHT_RAIN_SNOW ((FIT_WEATHER_STATUS)20) +#define FIT_WEATHER_STATUS_HEAVY_RAIN_SNOW ((FIT_WEATHER_STATUS)21) +#define FIT_WEATHER_STATUS_CLOUDY ((FIT_WEATHER_STATUS)22) +#define FIT_WEATHER_STATUS_COUNT 21 + +typedef FIT_ENUM FIT_WEATHER_SEVERITY; +#define FIT_WEATHER_SEVERITY_INVALID FIT_ENUM_INVALID +#define FIT_WEATHER_SEVERITY_UNKNOWN ((FIT_WEATHER_SEVERITY)0) +#define FIT_WEATHER_SEVERITY_WARNING ((FIT_WEATHER_SEVERITY)1) +#define FIT_WEATHER_SEVERITY_WATCH ((FIT_WEATHER_SEVERITY)2) +#define FIT_WEATHER_SEVERITY_ADVISORY ((FIT_WEATHER_SEVERITY)3) +#define FIT_WEATHER_SEVERITY_STATEMENT ((FIT_WEATHER_SEVERITY)4) +#define FIT_WEATHER_SEVERITY_COUNT 5 + +typedef FIT_ENUM FIT_WEATHER_SEVERE_TYPE; +#define FIT_WEATHER_SEVERE_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_WEATHER_SEVERE_TYPE_UNSPECIFIED ((FIT_WEATHER_SEVERE_TYPE)0) +#define FIT_WEATHER_SEVERE_TYPE_TORNADO ((FIT_WEATHER_SEVERE_TYPE)1) +#define FIT_WEATHER_SEVERE_TYPE_TSUNAMI ((FIT_WEATHER_SEVERE_TYPE)2) +#define FIT_WEATHER_SEVERE_TYPE_HURRICANE ((FIT_WEATHER_SEVERE_TYPE)3) +#define FIT_WEATHER_SEVERE_TYPE_EXTREME_WIND ((FIT_WEATHER_SEVERE_TYPE)4) +#define FIT_WEATHER_SEVERE_TYPE_TYPHOON ((FIT_WEATHER_SEVERE_TYPE)5) +#define FIT_WEATHER_SEVERE_TYPE_INLAND_HURRICANE ((FIT_WEATHER_SEVERE_TYPE)6) +#define FIT_WEATHER_SEVERE_TYPE_HURRICANE_FORCE_WIND ((FIT_WEATHER_SEVERE_TYPE)7) +#define FIT_WEATHER_SEVERE_TYPE_WATERSPOUT ((FIT_WEATHER_SEVERE_TYPE)8) +#define FIT_WEATHER_SEVERE_TYPE_SEVERE_THUNDERSTORM ((FIT_WEATHER_SEVERE_TYPE)9) +#define FIT_WEATHER_SEVERE_TYPE_WRECKHOUSE_WINDS ((FIT_WEATHER_SEVERE_TYPE)10) +#define FIT_WEATHER_SEVERE_TYPE_LES_SUETES_WIND ((FIT_WEATHER_SEVERE_TYPE)11) +#define FIT_WEATHER_SEVERE_TYPE_AVALANCHE ((FIT_WEATHER_SEVERE_TYPE)12) +#define FIT_WEATHER_SEVERE_TYPE_FLASH_FLOOD ((FIT_WEATHER_SEVERE_TYPE)13) +#define FIT_WEATHER_SEVERE_TYPE_TROPICAL_STORM ((FIT_WEATHER_SEVERE_TYPE)14) +#define FIT_WEATHER_SEVERE_TYPE_INLAND_TROPICAL_STORM ((FIT_WEATHER_SEVERE_TYPE)15) +#define FIT_WEATHER_SEVERE_TYPE_BLIZZARD ((FIT_WEATHER_SEVERE_TYPE)16) +#define FIT_WEATHER_SEVERE_TYPE_ICE_STORM ((FIT_WEATHER_SEVERE_TYPE)17) +#define FIT_WEATHER_SEVERE_TYPE_FREEZING_RAIN ((FIT_WEATHER_SEVERE_TYPE)18) +#define FIT_WEATHER_SEVERE_TYPE_DEBRIS_FLOW ((FIT_WEATHER_SEVERE_TYPE)19) +#define FIT_WEATHER_SEVERE_TYPE_FLASH_FREEZE ((FIT_WEATHER_SEVERE_TYPE)20) +#define FIT_WEATHER_SEVERE_TYPE_DUST_STORM ((FIT_WEATHER_SEVERE_TYPE)21) +#define FIT_WEATHER_SEVERE_TYPE_HIGH_WIND ((FIT_WEATHER_SEVERE_TYPE)22) +#define FIT_WEATHER_SEVERE_TYPE_WINTER_STORM ((FIT_WEATHER_SEVERE_TYPE)23) +#define FIT_WEATHER_SEVERE_TYPE_HEAVY_FREEZING_SPRAY ((FIT_WEATHER_SEVERE_TYPE)24) +#define FIT_WEATHER_SEVERE_TYPE_EXTREME_COLD ((FIT_WEATHER_SEVERE_TYPE)25) +#define FIT_WEATHER_SEVERE_TYPE_WIND_CHILL ((FIT_WEATHER_SEVERE_TYPE)26) +#define FIT_WEATHER_SEVERE_TYPE_COLD_WAVE ((FIT_WEATHER_SEVERE_TYPE)27) +#define FIT_WEATHER_SEVERE_TYPE_HEAVY_SNOW_ALERT ((FIT_WEATHER_SEVERE_TYPE)28) +#define FIT_WEATHER_SEVERE_TYPE_LAKE_EFFECT_BLOWING_SNOW ((FIT_WEATHER_SEVERE_TYPE)29) +#define FIT_WEATHER_SEVERE_TYPE_SNOW_SQUALL ((FIT_WEATHER_SEVERE_TYPE)30) +#define FIT_WEATHER_SEVERE_TYPE_LAKE_EFFECT_SNOW ((FIT_WEATHER_SEVERE_TYPE)31) +#define FIT_WEATHER_SEVERE_TYPE_WINTER_WEATHER ((FIT_WEATHER_SEVERE_TYPE)32) +#define FIT_WEATHER_SEVERE_TYPE_SLEET ((FIT_WEATHER_SEVERE_TYPE)33) +#define FIT_WEATHER_SEVERE_TYPE_SNOWFALL ((FIT_WEATHER_SEVERE_TYPE)34) +#define FIT_WEATHER_SEVERE_TYPE_SNOW_AND_BLOWING_SNOW ((FIT_WEATHER_SEVERE_TYPE)35) +#define FIT_WEATHER_SEVERE_TYPE_BLOWING_SNOW ((FIT_WEATHER_SEVERE_TYPE)36) +#define FIT_WEATHER_SEVERE_TYPE_SNOW_ALERT ((FIT_WEATHER_SEVERE_TYPE)37) +#define FIT_WEATHER_SEVERE_TYPE_ARCTIC_OUTFLOW ((FIT_WEATHER_SEVERE_TYPE)38) +#define FIT_WEATHER_SEVERE_TYPE_FREEZING_DRIZZLE ((FIT_WEATHER_SEVERE_TYPE)39) +#define FIT_WEATHER_SEVERE_TYPE_STORM ((FIT_WEATHER_SEVERE_TYPE)40) +#define FIT_WEATHER_SEVERE_TYPE_STORM_SURGE ((FIT_WEATHER_SEVERE_TYPE)41) +#define FIT_WEATHER_SEVERE_TYPE_RAINFALL ((FIT_WEATHER_SEVERE_TYPE)42) +#define FIT_WEATHER_SEVERE_TYPE_AREAL_FLOOD ((FIT_WEATHER_SEVERE_TYPE)43) +#define FIT_WEATHER_SEVERE_TYPE_COASTAL_FLOOD ((FIT_WEATHER_SEVERE_TYPE)44) +#define FIT_WEATHER_SEVERE_TYPE_LAKESHORE_FLOOD ((FIT_WEATHER_SEVERE_TYPE)45) +#define FIT_WEATHER_SEVERE_TYPE_EXCESSIVE_HEAT ((FIT_WEATHER_SEVERE_TYPE)46) +#define FIT_WEATHER_SEVERE_TYPE_HEAT ((FIT_WEATHER_SEVERE_TYPE)47) +#define FIT_WEATHER_SEVERE_TYPE_WEATHER ((FIT_WEATHER_SEVERE_TYPE)48) +#define FIT_WEATHER_SEVERE_TYPE_HIGH_HEAT_AND_HUMIDITY ((FIT_WEATHER_SEVERE_TYPE)49) +#define FIT_WEATHER_SEVERE_TYPE_HUMIDEX_AND_HEALTH ((FIT_WEATHER_SEVERE_TYPE)50) +#define FIT_WEATHER_SEVERE_TYPE_HUMIDEX ((FIT_WEATHER_SEVERE_TYPE)51) +#define FIT_WEATHER_SEVERE_TYPE_GALE ((FIT_WEATHER_SEVERE_TYPE)52) +#define FIT_WEATHER_SEVERE_TYPE_FREEZING_SPRAY ((FIT_WEATHER_SEVERE_TYPE)53) +#define FIT_WEATHER_SEVERE_TYPE_SPECIAL_MARINE ((FIT_WEATHER_SEVERE_TYPE)54) +#define FIT_WEATHER_SEVERE_TYPE_SQUALL ((FIT_WEATHER_SEVERE_TYPE)55) +#define FIT_WEATHER_SEVERE_TYPE_STRONG_WIND ((FIT_WEATHER_SEVERE_TYPE)56) +#define FIT_WEATHER_SEVERE_TYPE_LAKE_WIND ((FIT_WEATHER_SEVERE_TYPE)57) +#define FIT_WEATHER_SEVERE_TYPE_MARINE_WEATHER ((FIT_WEATHER_SEVERE_TYPE)58) +#define FIT_WEATHER_SEVERE_TYPE_WIND ((FIT_WEATHER_SEVERE_TYPE)59) +#define FIT_WEATHER_SEVERE_TYPE_SMALL_CRAFT_HAZARDOUS_SEAS ((FIT_WEATHER_SEVERE_TYPE)60) +#define FIT_WEATHER_SEVERE_TYPE_HAZARDOUS_SEAS ((FIT_WEATHER_SEVERE_TYPE)61) +#define FIT_WEATHER_SEVERE_TYPE_SMALL_CRAFT ((FIT_WEATHER_SEVERE_TYPE)62) +#define FIT_WEATHER_SEVERE_TYPE_SMALL_CRAFT_WINDS ((FIT_WEATHER_SEVERE_TYPE)63) +#define FIT_WEATHER_SEVERE_TYPE_SMALL_CRAFT_ROUGH_BAR ((FIT_WEATHER_SEVERE_TYPE)64) +#define FIT_WEATHER_SEVERE_TYPE_HIGH_WATER_LEVEL ((FIT_WEATHER_SEVERE_TYPE)65) +#define FIT_WEATHER_SEVERE_TYPE_ASHFALL ((FIT_WEATHER_SEVERE_TYPE)66) +#define FIT_WEATHER_SEVERE_TYPE_FREEZING_FOG ((FIT_WEATHER_SEVERE_TYPE)67) +#define FIT_WEATHER_SEVERE_TYPE_DENSE_FOG ((FIT_WEATHER_SEVERE_TYPE)68) +#define FIT_WEATHER_SEVERE_TYPE_DENSE_SMOKE ((FIT_WEATHER_SEVERE_TYPE)69) +#define FIT_WEATHER_SEVERE_TYPE_BLOWING_DUST ((FIT_WEATHER_SEVERE_TYPE)70) +#define FIT_WEATHER_SEVERE_TYPE_HARD_FREEZE ((FIT_WEATHER_SEVERE_TYPE)71) +#define FIT_WEATHER_SEVERE_TYPE_FREEZE ((FIT_WEATHER_SEVERE_TYPE)72) +#define FIT_WEATHER_SEVERE_TYPE_FROST ((FIT_WEATHER_SEVERE_TYPE)73) +#define FIT_WEATHER_SEVERE_TYPE_FIRE_WEATHER ((FIT_WEATHER_SEVERE_TYPE)74) +#define FIT_WEATHER_SEVERE_TYPE_FLOOD ((FIT_WEATHER_SEVERE_TYPE)75) +#define FIT_WEATHER_SEVERE_TYPE_RIP_TIDE ((FIT_WEATHER_SEVERE_TYPE)76) +#define FIT_WEATHER_SEVERE_TYPE_HIGH_SURF ((FIT_WEATHER_SEVERE_TYPE)77) +#define FIT_WEATHER_SEVERE_TYPE_SMOG ((FIT_WEATHER_SEVERE_TYPE)78) +#define FIT_WEATHER_SEVERE_TYPE_AIR_QUALITY ((FIT_WEATHER_SEVERE_TYPE)79) +#define FIT_WEATHER_SEVERE_TYPE_BRISK_WIND ((FIT_WEATHER_SEVERE_TYPE)80) +#define FIT_WEATHER_SEVERE_TYPE_AIR_STAGNATION ((FIT_WEATHER_SEVERE_TYPE)81) +#define FIT_WEATHER_SEVERE_TYPE_LOW_WATER ((FIT_WEATHER_SEVERE_TYPE)82) +#define FIT_WEATHER_SEVERE_TYPE_HYDROLOGICAL ((FIT_WEATHER_SEVERE_TYPE)83) +#define FIT_WEATHER_SEVERE_TYPE_SPECIAL_WEATHER ((FIT_WEATHER_SEVERE_TYPE)84) +#define FIT_WEATHER_SEVERE_TYPE_COUNT 85 + +typedef FIT_UINT32 FIT_TIME_INTO_DAY; // number of seconds into the day since 00:00:00 UTC +#define FIT_TIME_INTO_DAY_INVALID FIT_UINT32_INVALID +#define FIT_TIME_INTO_DAY_COUNT 0 + +typedef FIT_UINT32 FIT_LOCALTIME_INTO_DAY; // number of seconds into the day since local 00:00:00 +#define FIT_LOCALTIME_INTO_DAY_INVALID FIT_UINT32_INVALID +#define FIT_LOCALTIME_INTO_DAY_COUNT 0 + +typedef FIT_ENUM FIT_STROKE_TYPE; +#define FIT_STROKE_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_STROKE_TYPE_NO_EVENT ((FIT_STROKE_TYPE)0) +#define FIT_STROKE_TYPE_OTHER ((FIT_STROKE_TYPE)1) // stroke was detected but cannot be identified +#define FIT_STROKE_TYPE_SERVE ((FIT_STROKE_TYPE)2) +#define FIT_STROKE_TYPE_FOREHAND ((FIT_STROKE_TYPE)3) +#define FIT_STROKE_TYPE_BACKHAND ((FIT_STROKE_TYPE)4) +#define FIT_STROKE_TYPE_SMASH ((FIT_STROKE_TYPE)5) +#define FIT_STROKE_TYPE_COUNT 6 + +typedef FIT_ENUM FIT_BODY_LOCATION; +#define FIT_BODY_LOCATION_INVALID FIT_ENUM_INVALID +#define FIT_BODY_LOCATION_LEFT_LEG ((FIT_BODY_LOCATION)0) +#define FIT_BODY_LOCATION_LEFT_CALF ((FIT_BODY_LOCATION)1) +#define FIT_BODY_LOCATION_LEFT_SHIN ((FIT_BODY_LOCATION)2) +#define FIT_BODY_LOCATION_LEFT_HAMSTRING ((FIT_BODY_LOCATION)3) +#define FIT_BODY_LOCATION_LEFT_QUAD ((FIT_BODY_LOCATION)4) +#define FIT_BODY_LOCATION_LEFT_GLUTE ((FIT_BODY_LOCATION)5) +#define FIT_BODY_LOCATION_RIGHT_LEG ((FIT_BODY_LOCATION)6) +#define FIT_BODY_LOCATION_RIGHT_CALF ((FIT_BODY_LOCATION)7) +#define FIT_BODY_LOCATION_RIGHT_SHIN ((FIT_BODY_LOCATION)8) +#define FIT_BODY_LOCATION_RIGHT_HAMSTRING ((FIT_BODY_LOCATION)9) +#define FIT_BODY_LOCATION_RIGHT_QUAD ((FIT_BODY_LOCATION)10) +#define FIT_BODY_LOCATION_RIGHT_GLUTE ((FIT_BODY_LOCATION)11) +#define FIT_BODY_LOCATION_TORSO_BACK ((FIT_BODY_LOCATION)12) +#define FIT_BODY_LOCATION_LEFT_LOWER_BACK ((FIT_BODY_LOCATION)13) +#define FIT_BODY_LOCATION_LEFT_UPPER_BACK ((FIT_BODY_LOCATION)14) +#define FIT_BODY_LOCATION_RIGHT_LOWER_BACK ((FIT_BODY_LOCATION)15) +#define FIT_BODY_LOCATION_RIGHT_UPPER_BACK ((FIT_BODY_LOCATION)16) +#define FIT_BODY_LOCATION_TORSO_FRONT ((FIT_BODY_LOCATION)17) +#define FIT_BODY_LOCATION_LEFT_ABDOMEN ((FIT_BODY_LOCATION)18) +#define FIT_BODY_LOCATION_LEFT_CHEST ((FIT_BODY_LOCATION)19) +#define FIT_BODY_LOCATION_RIGHT_ABDOMEN ((FIT_BODY_LOCATION)20) +#define FIT_BODY_LOCATION_RIGHT_CHEST ((FIT_BODY_LOCATION)21) +#define FIT_BODY_LOCATION_LEFT_ARM ((FIT_BODY_LOCATION)22) +#define FIT_BODY_LOCATION_LEFT_SHOULDER ((FIT_BODY_LOCATION)23) +#define FIT_BODY_LOCATION_LEFT_BICEP ((FIT_BODY_LOCATION)24) +#define FIT_BODY_LOCATION_LEFT_TRICEP ((FIT_BODY_LOCATION)25) +#define FIT_BODY_LOCATION_LEFT_BRACHIORADIALIS ((FIT_BODY_LOCATION)26) // Left anterior forearm +#define FIT_BODY_LOCATION_LEFT_FOREARM_EXTENSORS ((FIT_BODY_LOCATION)27) // Left posterior forearm +#define FIT_BODY_LOCATION_RIGHT_ARM ((FIT_BODY_LOCATION)28) +#define FIT_BODY_LOCATION_RIGHT_SHOULDER ((FIT_BODY_LOCATION)29) +#define FIT_BODY_LOCATION_RIGHT_BICEP ((FIT_BODY_LOCATION)30) +#define FIT_BODY_LOCATION_RIGHT_TRICEP ((FIT_BODY_LOCATION)31) +#define FIT_BODY_LOCATION_RIGHT_BRACHIORADIALIS ((FIT_BODY_LOCATION)32) // Right anterior forearm +#define FIT_BODY_LOCATION_RIGHT_FOREARM_EXTENSORS ((FIT_BODY_LOCATION)33) // Right posterior forearm +#define FIT_BODY_LOCATION_NECK ((FIT_BODY_LOCATION)34) +#define FIT_BODY_LOCATION_THROAT ((FIT_BODY_LOCATION)35) +#define FIT_BODY_LOCATION_WAIST_MID_BACK ((FIT_BODY_LOCATION)36) +#define FIT_BODY_LOCATION_WAIST_FRONT ((FIT_BODY_LOCATION)37) +#define FIT_BODY_LOCATION_WAIST_LEFT ((FIT_BODY_LOCATION)38) +#define FIT_BODY_LOCATION_WAIST_RIGHT ((FIT_BODY_LOCATION)39) +#define FIT_BODY_LOCATION_COUNT 40 + +typedef FIT_ENUM FIT_SEGMENT_LAP_STATUS; +#define FIT_SEGMENT_LAP_STATUS_INVALID FIT_ENUM_INVALID +#define FIT_SEGMENT_LAP_STATUS_END ((FIT_SEGMENT_LAP_STATUS)0) +#define FIT_SEGMENT_LAP_STATUS_FAIL ((FIT_SEGMENT_LAP_STATUS)1) +#define FIT_SEGMENT_LAP_STATUS_COUNT 2 + +typedef FIT_ENUM FIT_SEGMENT_LEADERBOARD_TYPE; +#define FIT_SEGMENT_LEADERBOARD_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_SEGMENT_LEADERBOARD_TYPE_OVERALL ((FIT_SEGMENT_LEADERBOARD_TYPE)0) +#define FIT_SEGMENT_LEADERBOARD_TYPE_PERSONAL_BEST ((FIT_SEGMENT_LEADERBOARD_TYPE)1) +#define FIT_SEGMENT_LEADERBOARD_TYPE_CONNECTIONS ((FIT_SEGMENT_LEADERBOARD_TYPE)2) +#define FIT_SEGMENT_LEADERBOARD_TYPE_GROUP ((FIT_SEGMENT_LEADERBOARD_TYPE)3) +#define FIT_SEGMENT_LEADERBOARD_TYPE_CHALLENGER ((FIT_SEGMENT_LEADERBOARD_TYPE)4) +#define FIT_SEGMENT_LEADERBOARD_TYPE_KOM ((FIT_SEGMENT_LEADERBOARD_TYPE)5) +#define FIT_SEGMENT_LEADERBOARD_TYPE_QOM ((FIT_SEGMENT_LEADERBOARD_TYPE)6) +#define FIT_SEGMENT_LEADERBOARD_TYPE_PR ((FIT_SEGMENT_LEADERBOARD_TYPE)7) +#define FIT_SEGMENT_LEADERBOARD_TYPE_GOAL ((FIT_SEGMENT_LEADERBOARD_TYPE)8) +#define FIT_SEGMENT_LEADERBOARD_TYPE_CARROT ((FIT_SEGMENT_LEADERBOARD_TYPE)9) +#define FIT_SEGMENT_LEADERBOARD_TYPE_CLUB_LEADER ((FIT_SEGMENT_LEADERBOARD_TYPE)10) +#define FIT_SEGMENT_LEADERBOARD_TYPE_RIVAL ((FIT_SEGMENT_LEADERBOARD_TYPE)11) +#define FIT_SEGMENT_LEADERBOARD_TYPE_LAST ((FIT_SEGMENT_LEADERBOARD_TYPE)12) +#define FIT_SEGMENT_LEADERBOARD_TYPE_RECENT_BEST ((FIT_SEGMENT_LEADERBOARD_TYPE)13) +#define FIT_SEGMENT_LEADERBOARD_TYPE_COURSE_RECORD ((FIT_SEGMENT_LEADERBOARD_TYPE)14) +#define FIT_SEGMENT_LEADERBOARD_TYPE_COUNT 15 + +typedef FIT_ENUM FIT_SEGMENT_DELETE_STATUS; +#define FIT_SEGMENT_DELETE_STATUS_INVALID FIT_ENUM_INVALID +#define FIT_SEGMENT_DELETE_STATUS_DO_NOT_DELETE ((FIT_SEGMENT_DELETE_STATUS)0) +#define FIT_SEGMENT_DELETE_STATUS_DELETE_ONE ((FIT_SEGMENT_DELETE_STATUS)1) +#define FIT_SEGMENT_DELETE_STATUS_DELETE_ALL ((FIT_SEGMENT_DELETE_STATUS)2) +#define FIT_SEGMENT_DELETE_STATUS_COUNT 3 + +typedef FIT_ENUM FIT_SEGMENT_SELECTION_TYPE; +#define FIT_SEGMENT_SELECTION_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_SEGMENT_SELECTION_TYPE_STARRED ((FIT_SEGMENT_SELECTION_TYPE)0) +#define FIT_SEGMENT_SELECTION_TYPE_SUGGESTED ((FIT_SEGMENT_SELECTION_TYPE)1) +#define FIT_SEGMENT_SELECTION_TYPE_COUNT 2 + +typedef FIT_ENUM FIT_SOURCE_TYPE; +#define FIT_SOURCE_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_SOURCE_TYPE_ANT ((FIT_SOURCE_TYPE)0) // External device connected with ANT +#define FIT_SOURCE_TYPE_ANTPLUS ((FIT_SOURCE_TYPE)1) // External device connected with ANT+ +#define FIT_SOURCE_TYPE_BLUETOOTH ((FIT_SOURCE_TYPE)2) // External device connected with BT +#define FIT_SOURCE_TYPE_BLUETOOTH_LOW_ENERGY ((FIT_SOURCE_TYPE)3) // External device connected with BLE +#define FIT_SOURCE_TYPE_WIFI ((FIT_SOURCE_TYPE)4) // External device connected with Wifi +#define FIT_SOURCE_TYPE_LOCAL ((FIT_SOURCE_TYPE)5) // Onboard device +#define FIT_SOURCE_TYPE_COUNT 6 + +typedef FIT_UINT8 FIT_LOCAL_DEVICE_TYPE; +#define FIT_LOCAL_DEVICE_TYPE_INVALID FIT_UINT8_INVALID +#define FIT_LOCAL_DEVICE_TYPE_GPS ((FIT_LOCAL_DEVICE_TYPE)0) // Onboard gps receiver +#define FIT_LOCAL_DEVICE_TYPE_GLONASS ((FIT_LOCAL_DEVICE_TYPE)1) // Onboard glonass receiver +#define FIT_LOCAL_DEVICE_TYPE_GPS_GLONASS ((FIT_LOCAL_DEVICE_TYPE)2) // Onboard gps glonass receiver +#define FIT_LOCAL_DEVICE_TYPE_ACCELEROMETER ((FIT_LOCAL_DEVICE_TYPE)3) // Onboard sensor +#define FIT_LOCAL_DEVICE_TYPE_BAROMETER ((FIT_LOCAL_DEVICE_TYPE)4) // Onboard sensor +#define FIT_LOCAL_DEVICE_TYPE_TEMPERATURE ((FIT_LOCAL_DEVICE_TYPE)5) // Onboard sensor +#define FIT_LOCAL_DEVICE_TYPE_WHR ((FIT_LOCAL_DEVICE_TYPE)10) // Onboard wrist HR sensor +#define FIT_LOCAL_DEVICE_TYPE_SENSOR_HUB ((FIT_LOCAL_DEVICE_TYPE)12) // Onboard software package +#define FIT_LOCAL_DEVICE_TYPE_COUNT 8 + +typedef FIT_UINT8 FIT_BLE_DEVICE_TYPE; +#define FIT_BLE_DEVICE_TYPE_INVALID FIT_UINT8_INVALID +#define FIT_BLE_DEVICE_TYPE_CONNECTED_GPS ((FIT_BLE_DEVICE_TYPE)0) // GPS that is provided over a proprietary bluetooth service +#define FIT_BLE_DEVICE_TYPE_HEART_RATE ((FIT_BLE_DEVICE_TYPE)1) +#define FIT_BLE_DEVICE_TYPE_BIKE_POWER ((FIT_BLE_DEVICE_TYPE)2) +#define FIT_BLE_DEVICE_TYPE_BIKE_SPEED_CADENCE ((FIT_BLE_DEVICE_TYPE)3) +#define FIT_BLE_DEVICE_TYPE_BIKE_SPEED ((FIT_BLE_DEVICE_TYPE)4) +#define FIT_BLE_DEVICE_TYPE_BIKE_CADENCE ((FIT_BLE_DEVICE_TYPE)5) +#define FIT_BLE_DEVICE_TYPE_FOOTPOD ((FIT_BLE_DEVICE_TYPE)6) +#define FIT_BLE_DEVICE_TYPE_BIKE_TRAINER ((FIT_BLE_DEVICE_TYPE)7) // Indoor-Bike FTMS protocol +#define FIT_BLE_DEVICE_TYPE_COUNT 8 + +typedef FIT_UINT32Z FIT_ANT_CHANNEL_ID; +#define FIT_ANT_CHANNEL_ID_INVALID FIT_UINT32Z_INVALID +#define FIT_ANT_CHANNEL_ID_ANT_EXTENDED_DEVICE_NUMBER_UPPER_NIBBLE ((FIT_ANT_CHANNEL_ID)0xF0000000) +#define FIT_ANT_CHANNEL_ID_ANT_TRANSMISSION_TYPE_LOWER_NIBBLE ((FIT_ANT_CHANNEL_ID)0x0F000000) +#define FIT_ANT_CHANNEL_ID_ANT_DEVICE_TYPE ((FIT_ANT_CHANNEL_ID)0x00FF0000) +#define FIT_ANT_CHANNEL_ID_ANT_DEVICE_NUMBER ((FIT_ANT_CHANNEL_ID)0x0000FFFF) +#define FIT_ANT_CHANNEL_ID_COUNT 4 + +typedef FIT_ENUM FIT_DISPLAY_ORIENTATION; +#define FIT_DISPLAY_ORIENTATION_INVALID FIT_ENUM_INVALID +#define FIT_DISPLAY_ORIENTATION_AUTO ((FIT_DISPLAY_ORIENTATION)0) // automatic if the device supports it +#define FIT_DISPLAY_ORIENTATION_PORTRAIT ((FIT_DISPLAY_ORIENTATION)1) +#define FIT_DISPLAY_ORIENTATION_LANDSCAPE ((FIT_DISPLAY_ORIENTATION)2) +#define FIT_DISPLAY_ORIENTATION_PORTRAIT_FLIPPED ((FIT_DISPLAY_ORIENTATION)3) // portrait mode but rotated 180 degrees +#define FIT_DISPLAY_ORIENTATION_LANDSCAPE_FLIPPED ((FIT_DISPLAY_ORIENTATION)4) // landscape mode but rotated 180 degrees +#define FIT_DISPLAY_ORIENTATION_COUNT 5 + +typedef FIT_ENUM FIT_WORKOUT_EQUIPMENT; +#define FIT_WORKOUT_EQUIPMENT_INVALID FIT_ENUM_INVALID +#define FIT_WORKOUT_EQUIPMENT_NONE ((FIT_WORKOUT_EQUIPMENT)0) +#define FIT_WORKOUT_EQUIPMENT_SWIM_FINS ((FIT_WORKOUT_EQUIPMENT)1) +#define FIT_WORKOUT_EQUIPMENT_SWIM_KICKBOARD ((FIT_WORKOUT_EQUIPMENT)2) +#define FIT_WORKOUT_EQUIPMENT_SWIM_PADDLES ((FIT_WORKOUT_EQUIPMENT)3) +#define FIT_WORKOUT_EQUIPMENT_SWIM_PULL_BUOY ((FIT_WORKOUT_EQUIPMENT)4) +#define FIT_WORKOUT_EQUIPMENT_SWIM_SNORKEL ((FIT_WORKOUT_EQUIPMENT)5) +#define FIT_WORKOUT_EQUIPMENT_COUNT 6 + +typedef FIT_ENUM FIT_WATCHFACE_MODE; +#define FIT_WATCHFACE_MODE_INVALID FIT_ENUM_INVALID +#define FIT_WATCHFACE_MODE_DIGITAL ((FIT_WATCHFACE_MODE)0) +#define FIT_WATCHFACE_MODE_ANALOG ((FIT_WATCHFACE_MODE)1) +#define FIT_WATCHFACE_MODE_CONNECT_IQ ((FIT_WATCHFACE_MODE)2) +#define FIT_WATCHFACE_MODE_DISABLED ((FIT_WATCHFACE_MODE)3) +#define FIT_WATCHFACE_MODE_COUNT 4 + +typedef FIT_ENUM FIT_DIGITAL_WATCHFACE_LAYOUT; +#define FIT_DIGITAL_WATCHFACE_LAYOUT_INVALID FIT_ENUM_INVALID +#define FIT_DIGITAL_WATCHFACE_LAYOUT_TRADITIONAL ((FIT_DIGITAL_WATCHFACE_LAYOUT)0) +#define FIT_DIGITAL_WATCHFACE_LAYOUT_MODERN ((FIT_DIGITAL_WATCHFACE_LAYOUT)1) +#define FIT_DIGITAL_WATCHFACE_LAYOUT_BOLD ((FIT_DIGITAL_WATCHFACE_LAYOUT)2) +#define FIT_DIGITAL_WATCHFACE_LAYOUT_COUNT 3 + +typedef FIT_ENUM FIT_ANALOG_WATCHFACE_LAYOUT; +#define FIT_ANALOG_WATCHFACE_LAYOUT_INVALID FIT_ENUM_INVALID +#define FIT_ANALOG_WATCHFACE_LAYOUT_MINIMAL ((FIT_ANALOG_WATCHFACE_LAYOUT)0) +#define FIT_ANALOG_WATCHFACE_LAYOUT_TRADITIONAL ((FIT_ANALOG_WATCHFACE_LAYOUT)1) +#define FIT_ANALOG_WATCHFACE_LAYOUT_MODERN ((FIT_ANALOG_WATCHFACE_LAYOUT)2) +#define FIT_ANALOG_WATCHFACE_LAYOUT_COUNT 3 + +typedef FIT_ENUM FIT_RIDER_POSITION_TYPE; +#define FIT_RIDER_POSITION_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_RIDER_POSITION_TYPE_SEATED ((FIT_RIDER_POSITION_TYPE)0) +#define FIT_RIDER_POSITION_TYPE_STANDING ((FIT_RIDER_POSITION_TYPE)1) +#define FIT_RIDER_POSITION_TYPE_TRANSITION_TO_SEATED ((FIT_RIDER_POSITION_TYPE)2) +#define FIT_RIDER_POSITION_TYPE_TRANSITION_TO_STANDING ((FIT_RIDER_POSITION_TYPE)3) +#define FIT_RIDER_POSITION_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_POWER_PHASE_TYPE; +#define FIT_POWER_PHASE_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_POWER_PHASE_TYPE_POWER_PHASE_START_ANGLE ((FIT_POWER_PHASE_TYPE)0) +#define FIT_POWER_PHASE_TYPE_POWER_PHASE_END_ANGLE ((FIT_POWER_PHASE_TYPE)1) +#define FIT_POWER_PHASE_TYPE_POWER_PHASE_ARC_LENGTH ((FIT_POWER_PHASE_TYPE)2) +#define FIT_POWER_PHASE_TYPE_POWER_PHASE_CENTER ((FIT_POWER_PHASE_TYPE)3) +#define FIT_POWER_PHASE_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_CAMERA_EVENT_TYPE; +#define FIT_CAMERA_EVENT_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_CAMERA_EVENT_TYPE_VIDEO_START ((FIT_CAMERA_EVENT_TYPE)0) // Start of video recording +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SPLIT ((FIT_CAMERA_EVENT_TYPE)1) // Mark of video file split (end of one file, beginning of the other) +#define FIT_CAMERA_EVENT_TYPE_VIDEO_END ((FIT_CAMERA_EVENT_TYPE)2) // End of video recording +#define FIT_CAMERA_EVENT_TYPE_PHOTO_TAKEN ((FIT_CAMERA_EVENT_TYPE)3) // Still photo taken +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SECOND_STREAM_START ((FIT_CAMERA_EVENT_TYPE)4) +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SECOND_STREAM_SPLIT ((FIT_CAMERA_EVENT_TYPE)5) +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SECOND_STREAM_END ((FIT_CAMERA_EVENT_TYPE)6) +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SPLIT_START ((FIT_CAMERA_EVENT_TYPE)7) // Mark of video file split start +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SECOND_STREAM_SPLIT_START ((FIT_CAMERA_EVENT_TYPE)8) +#define FIT_CAMERA_EVENT_TYPE_VIDEO_PAUSE ((FIT_CAMERA_EVENT_TYPE)11) // Mark when a video recording has been paused +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SECOND_STREAM_PAUSE ((FIT_CAMERA_EVENT_TYPE)12) +#define FIT_CAMERA_EVENT_TYPE_VIDEO_RESUME ((FIT_CAMERA_EVENT_TYPE)13) // Mark when a video recording has been resumed +#define FIT_CAMERA_EVENT_TYPE_VIDEO_SECOND_STREAM_RESUME ((FIT_CAMERA_EVENT_TYPE)14) +#define FIT_CAMERA_EVENT_TYPE_COUNT 13 + +typedef FIT_ENUM FIT_SENSOR_TYPE; +#define FIT_SENSOR_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_SENSOR_TYPE_ACCELEROMETER ((FIT_SENSOR_TYPE)0) +#define FIT_SENSOR_TYPE_GYROSCOPE ((FIT_SENSOR_TYPE)1) +#define FIT_SENSOR_TYPE_COMPASS ((FIT_SENSOR_TYPE)2) // Magnetometer +#define FIT_SENSOR_TYPE_BAROMETER ((FIT_SENSOR_TYPE)3) +#define FIT_SENSOR_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE; +#define FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE_AUTO ((FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE)0) +#define FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE_INDIVIDUAL ((FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE)4) +#define FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE_HIGH_VISIBILITY ((FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE)5) +#define FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE_TRAIL ((FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE)6) +#define FIT_BIKE_LIGHT_NETWORK_CONFIG_TYPE_COUNT 4 + +typedef FIT_UINT16 FIT_COMM_TIMEOUT_TYPE; +#define FIT_COMM_TIMEOUT_TYPE_INVALID FIT_UINT16_INVALID +#define FIT_COMM_TIMEOUT_TYPE_WILDCARD_PAIRING_TIMEOUT ((FIT_COMM_TIMEOUT_TYPE)0) // Timeout pairing to any device +#define FIT_COMM_TIMEOUT_TYPE_PAIRING_TIMEOUT ((FIT_COMM_TIMEOUT_TYPE)1) // Timeout pairing to previously paired device +#define FIT_COMM_TIMEOUT_TYPE_CONNECTION_LOST ((FIT_COMM_TIMEOUT_TYPE)2) // Temporary loss of communications +#define FIT_COMM_TIMEOUT_TYPE_CONNECTION_TIMEOUT ((FIT_COMM_TIMEOUT_TYPE)3) // Connection closed due to extended bad communications +#define FIT_COMM_TIMEOUT_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_CAMERA_ORIENTATION_TYPE; +#define FIT_CAMERA_ORIENTATION_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_CAMERA_ORIENTATION_TYPE_CAMERA_ORIENTATION_0 ((FIT_CAMERA_ORIENTATION_TYPE)0) +#define FIT_CAMERA_ORIENTATION_TYPE_CAMERA_ORIENTATION_90 ((FIT_CAMERA_ORIENTATION_TYPE)1) +#define FIT_CAMERA_ORIENTATION_TYPE_CAMERA_ORIENTATION_180 ((FIT_CAMERA_ORIENTATION_TYPE)2) +#define FIT_CAMERA_ORIENTATION_TYPE_CAMERA_ORIENTATION_270 ((FIT_CAMERA_ORIENTATION_TYPE)3) +#define FIT_CAMERA_ORIENTATION_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_ATTITUDE_STAGE; +#define FIT_ATTITUDE_STAGE_INVALID FIT_ENUM_INVALID +#define FIT_ATTITUDE_STAGE_FAILED ((FIT_ATTITUDE_STAGE)0) +#define FIT_ATTITUDE_STAGE_ALIGNING ((FIT_ATTITUDE_STAGE)1) +#define FIT_ATTITUDE_STAGE_DEGRADED ((FIT_ATTITUDE_STAGE)2) +#define FIT_ATTITUDE_STAGE_VALID ((FIT_ATTITUDE_STAGE)3) +#define FIT_ATTITUDE_STAGE_COUNT 4 + +typedef FIT_UINT16 FIT_ATTITUDE_VALIDITY; +#define FIT_ATTITUDE_VALIDITY_INVALID FIT_UINT16_INVALID +#define FIT_ATTITUDE_VALIDITY_TRACK_ANGLE_HEADING_VALID ((FIT_ATTITUDE_VALIDITY)0x0001) +#define FIT_ATTITUDE_VALIDITY_PITCH_VALID ((FIT_ATTITUDE_VALIDITY)0x0002) +#define FIT_ATTITUDE_VALIDITY_ROLL_VALID ((FIT_ATTITUDE_VALIDITY)0x0004) +#define FIT_ATTITUDE_VALIDITY_LATERAL_BODY_ACCEL_VALID ((FIT_ATTITUDE_VALIDITY)0x0008) +#define FIT_ATTITUDE_VALIDITY_NORMAL_BODY_ACCEL_VALID ((FIT_ATTITUDE_VALIDITY)0x0010) +#define FIT_ATTITUDE_VALIDITY_TURN_RATE_VALID ((FIT_ATTITUDE_VALIDITY)0x0020) +#define FIT_ATTITUDE_VALIDITY_HW_FAIL ((FIT_ATTITUDE_VALIDITY)0x0040) +#define FIT_ATTITUDE_VALIDITY_MAG_INVALID ((FIT_ATTITUDE_VALIDITY)0x0080) +#define FIT_ATTITUDE_VALIDITY_NO_GPS ((FIT_ATTITUDE_VALIDITY)0x0100) +#define FIT_ATTITUDE_VALIDITY_GPS_INVALID ((FIT_ATTITUDE_VALIDITY)0x0200) +#define FIT_ATTITUDE_VALIDITY_SOLUTION_COASTING ((FIT_ATTITUDE_VALIDITY)0x0400) +#define FIT_ATTITUDE_VALIDITY_TRUE_TRACK_ANGLE ((FIT_ATTITUDE_VALIDITY)0x0800) +#define FIT_ATTITUDE_VALIDITY_MAGNETIC_HEADING ((FIT_ATTITUDE_VALIDITY)0x1000) +#define FIT_ATTITUDE_VALIDITY_COUNT 13 + +typedef FIT_ENUM FIT_AUTO_SYNC_FREQUENCY; +#define FIT_AUTO_SYNC_FREQUENCY_INVALID FIT_ENUM_INVALID +#define FIT_AUTO_SYNC_FREQUENCY_NEVER ((FIT_AUTO_SYNC_FREQUENCY)0) +#define FIT_AUTO_SYNC_FREQUENCY_OCCASIONALLY ((FIT_AUTO_SYNC_FREQUENCY)1) +#define FIT_AUTO_SYNC_FREQUENCY_FREQUENT ((FIT_AUTO_SYNC_FREQUENCY)2) +#define FIT_AUTO_SYNC_FREQUENCY_ONCE_A_DAY ((FIT_AUTO_SYNC_FREQUENCY)3) +#define FIT_AUTO_SYNC_FREQUENCY_REMOTE ((FIT_AUTO_SYNC_FREQUENCY)4) +#define FIT_AUTO_SYNC_FREQUENCY_COUNT 5 + +typedef FIT_ENUM FIT_EXD_LAYOUT; +#define FIT_EXD_LAYOUT_INVALID FIT_ENUM_INVALID +#define FIT_EXD_LAYOUT_FULL_SCREEN ((FIT_EXD_LAYOUT)0) +#define FIT_EXD_LAYOUT_HALF_VERTICAL ((FIT_EXD_LAYOUT)1) +#define FIT_EXD_LAYOUT_HALF_HORIZONTAL ((FIT_EXD_LAYOUT)2) +#define FIT_EXD_LAYOUT_HALF_VERTICAL_RIGHT_SPLIT ((FIT_EXD_LAYOUT)3) +#define FIT_EXD_LAYOUT_HALF_HORIZONTAL_BOTTOM_SPLIT ((FIT_EXD_LAYOUT)4) +#define FIT_EXD_LAYOUT_FULL_QUARTER_SPLIT ((FIT_EXD_LAYOUT)5) +#define FIT_EXD_LAYOUT_HALF_VERTICAL_LEFT_SPLIT ((FIT_EXD_LAYOUT)6) +#define FIT_EXD_LAYOUT_HALF_HORIZONTAL_TOP_SPLIT ((FIT_EXD_LAYOUT)7) +#define FIT_EXD_LAYOUT_DYNAMIC ((FIT_EXD_LAYOUT)8) // The EXD may display the configured concepts in any layout it sees fit. +#define FIT_EXD_LAYOUT_COUNT 9 + +typedef FIT_ENUM FIT_EXD_DISPLAY_TYPE; +#define FIT_EXD_DISPLAY_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_EXD_DISPLAY_TYPE_NUMERICAL ((FIT_EXD_DISPLAY_TYPE)0) +#define FIT_EXD_DISPLAY_TYPE_SIMPLE ((FIT_EXD_DISPLAY_TYPE)1) +#define FIT_EXD_DISPLAY_TYPE_GRAPH ((FIT_EXD_DISPLAY_TYPE)2) +#define FIT_EXD_DISPLAY_TYPE_BAR ((FIT_EXD_DISPLAY_TYPE)3) +#define FIT_EXD_DISPLAY_TYPE_CIRCLE_GRAPH ((FIT_EXD_DISPLAY_TYPE)4) +#define FIT_EXD_DISPLAY_TYPE_VIRTUAL_PARTNER ((FIT_EXD_DISPLAY_TYPE)5) +#define FIT_EXD_DISPLAY_TYPE_BALANCE ((FIT_EXD_DISPLAY_TYPE)6) +#define FIT_EXD_DISPLAY_TYPE_STRING_LIST ((FIT_EXD_DISPLAY_TYPE)7) +#define FIT_EXD_DISPLAY_TYPE_STRING ((FIT_EXD_DISPLAY_TYPE)8) +#define FIT_EXD_DISPLAY_TYPE_SIMPLE_DYNAMIC_ICON ((FIT_EXD_DISPLAY_TYPE)9) +#define FIT_EXD_DISPLAY_TYPE_GAUGE ((FIT_EXD_DISPLAY_TYPE)10) +#define FIT_EXD_DISPLAY_TYPE_COUNT 11 + +typedef FIT_ENUM FIT_EXD_DATA_UNITS; +#define FIT_EXD_DATA_UNITS_INVALID FIT_ENUM_INVALID +#define FIT_EXD_DATA_UNITS_NO_UNITS ((FIT_EXD_DATA_UNITS)0) +#define FIT_EXD_DATA_UNITS_LAPS ((FIT_EXD_DATA_UNITS)1) +#define FIT_EXD_DATA_UNITS_MILES_PER_HOUR ((FIT_EXD_DATA_UNITS)2) +#define FIT_EXD_DATA_UNITS_KILOMETERS_PER_HOUR ((FIT_EXD_DATA_UNITS)3) +#define FIT_EXD_DATA_UNITS_FEET_PER_HOUR ((FIT_EXD_DATA_UNITS)4) +#define FIT_EXD_DATA_UNITS_METERS_PER_HOUR ((FIT_EXD_DATA_UNITS)5) +#define FIT_EXD_DATA_UNITS_DEGREES_CELSIUS ((FIT_EXD_DATA_UNITS)6) +#define FIT_EXD_DATA_UNITS_DEGREES_FARENHEIT ((FIT_EXD_DATA_UNITS)7) +#define FIT_EXD_DATA_UNITS_ZONE ((FIT_EXD_DATA_UNITS)8) +#define FIT_EXD_DATA_UNITS_GEAR ((FIT_EXD_DATA_UNITS)9) +#define FIT_EXD_DATA_UNITS_RPM ((FIT_EXD_DATA_UNITS)10) +#define FIT_EXD_DATA_UNITS_BPM ((FIT_EXD_DATA_UNITS)11) +#define FIT_EXD_DATA_UNITS_DEGREES ((FIT_EXD_DATA_UNITS)12) +#define FIT_EXD_DATA_UNITS_MILLIMETERS ((FIT_EXD_DATA_UNITS)13) +#define FIT_EXD_DATA_UNITS_METERS ((FIT_EXD_DATA_UNITS)14) +#define FIT_EXD_DATA_UNITS_KILOMETERS ((FIT_EXD_DATA_UNITS)15) +#define FIT_EXD_DATA_UNITS_FEET ((FIT_EXD_DATA_UNITS)16) +#define FIT_EXD_DATA_UNITS_YARDS ((FIT_EXD_DATA_UNITS)17) +#define FIT_EXD_DATA_UNITS_KILOFEET ((FIT_EXD_DATA_UNITS)18) +#define FIT_EXD_DATA_UNITS_MILES ((FIT_EXD_DATA_UNITS)19) +#define FIT_EXD_DATA_UNITS_TIME ((FIT_EXD_DATA_UNITS)20) +#define FIT_EXD_DATA_UNITS_ENUM_TURN_TYPE ((FIT_EXD_DATA_UNITS)21) +#define FIT_EXD_DATA_UNITS_PERCENT ((FIT_EXD_DATA_UNITS)22) +#define FIT_EXD_DATA_UNITS_WATTS ((FIT_EXD_DATA_UNITS)23) +#define FIT_EXD_DATA_UNITS_WATTS_PER_KILOGRAM ((FIT_EXD_DATA_UNITS)24) +#define FIT_EXD_DATA_UNITS_ENUM_BATTERY_STATUS ((FIT_EXD_DATA_UNITS)25) +#define FIT_EXD_DATA_UNITS_ENUM_BIKE_LIGHT_BEAM_ANGLE_MODE ((FIT_EXD_DATA_UNITS)26) +#define FIT_EXD_DATA_UNITS_ENUM_BIKE_LIGHT_BATTERY_STATUS ((FIT_EXD_DATA_UNITS)27) +#define FIT_EXD_DATA_UNITS_ENUM_BIKE_LIGHT_NETWORK_CONFIG_TYPE ((FIT_EXD_DATA_UNITS)28) +#define FIT_EXD_DATA_UNITS_LIGHTS ((FIT_EXD_DATA_UNITS)29) +#define FIT_EXD_DATA_UNITS_SECONDS ((FIT_EXD_DATA_UNITS)30) +#define FIT_EXD_DATA_UNITS_MINUTES ((FIT_EXD_DATA_UNITS)31) +#define FIT_EXD_DATA_UNITS_HOURS ((FIT_EXD_DATA_UNITS)32) +#define FIT_EXD_DATA_UNITS_CALORIES ((FIT_EXD_DATA_UNITS)33) +#define FIT_EXD_DATA_UNITS_KILOJOULES ((FIT_EXD_DATA_UNITS)34) +#define FIT_EXD_DATA_UNITS_MILLISECONDS ((FIT_EXD_DATA_UNITS)35) +#define FIT_EXD_DATA_UNITS_SECOND_PER_MILE ((FIT_EXD_DATA_UNITS)36) +#define FIT_EXD_DATA_UNITS_SECOND_PER_KILOMETER ((FIT_EXD_DATA_UNITS)37) +#define FIT_EXD_DATA_UNITS_CENTIMETER ((FIT_EXD_DATA_UNITS)38) +#define FIT_EXD_DATA_UNITS_ENUM_COURSE_POINT ((FIT_EXD_DATA_UNITS)39) +#define FIT_EXD_DATA_UNITS_BRADIANS ((FIT_EXD_DATA_UNITS)40) +#define FIT_EXD_DATA_UNITS_ENUM_SPORT ((FIT_EXD_DATA_UNITS)41) +#define FIT_EXD_DATA_UNITS_INCHES_HG ((FIT_EXD_DATA_UNITS)42) +#define FIT_EXD_DATA_UNITS_MM_HG ((FIT_EXD_DATA_UNITS)43) +#define FIT_EXD_DATA_UNITS_MBARS ((FIT_EXD_DATA_UNITS)44) +#define FIT_EXD_DATA_UNITS_HECTO_PASCALS ((FIT_EXD_DATA_UNITS)45) +#define FIT_EXD_DATA_UNITS_FEET_PER_MIN ((FIT_EXD_DATA_UNITS)46) +#define FIT_EXD_DATA_UNITS_METERS_PER_MIN ((FIT_EXD_DATA_UNITS)47) +#define FIT_EXD_DATA_UNITS_METERS_PER_SEC ((FIT_EXD_DATA_UNITS)48) +#define FIT_EXD_DATA_UNITS_EIGHT_CARDINAL ((FIT_EXD_DATA_UNITS)49) +#define FIT_EXD_DATA_UNITS_COUNT 50 + +typedef FIT_ENUM FIT_EXD_QUALIFIERS; +#define FIT_EXD_QUALIFIERS_INVALID FIT_ENUM_INVALID +#define FIT_EXD_QUALIFIERS_NO_QUALIFIER ((FIT_EXD_QUALIFIERS)0) +#define FIT_EXD_QUALIFIERS_INSTANTANEOUS ((FIT_EXD_QUALIFIERS)1) +#define FIT_EXD_QUALIFIERS_AVERAGE ((FIT_EXD_QUALIFIERS)2) +#define FIT_EXD_QUALIFIERS_LAP ((FIT_EXD_QUALIFIERS)3) +#define FIT_EXD_QUALIFIERS_MAXIMUM ((FIT_EXD_QUALIFIERS)4) +#define FIT_EXD_QUALIFIERS_MAXIMUM_AVERAGE ((FIT_EXD_QUALIFIERS)5) +#define FIT_EXD_QUALIFIERS_MAXIMUM_LAP ((FIT_EXD_QUALIFIERS)6) +#define FIT_EXD_QUALIFIERS_LAST_LAP ((FIT_EXD_QUALIFIERS)7) +#define FIT_EXD_QUALIFIERS_AVERAGE_LAP ((FIT_EXD_QUALIFIERS)8) +#define FIT_EXD_QUALIFIERS_TO_DESTINATION ((FIT_EXD_QUALIFIERS)9) +#define FIT_EXD_QUALIFIERS_TO_GO ((FIT_EXD_QUALIFIERS)10) +#define FIT_EXD_QUALIFIERS_TO_NEXT ((FIT_EXD_QUALIFIERS)11) +#define FIT_EXD_QUALIFIERS_NEXT_COURSE_POINT ((FIT_EXD_QUALIFIERS)12) +#define FIT_EXD_QUALIFIERS_TOTAL ((FIT_EXD_QUALIFIERS)13) +#define FIT_EXD_QUALIFIERS_THREE_SECOND_AVERAGE ((FIT_EXD_QUALIFIERS)14) +#define FIT_EXD_QUALIFIERS_TEN_SECOND_AVERAGE ((FIT_EXD_QUALIFIERS)15) +#define FIT_EXD_QUALIFIERS_THIRTY_SECOND_AVERAGE ((FIT_EXD_QUALIFIERS)16) +#define FIT_EXD_QUALIFIERS_PERCENT_MAXIMUM ((FIT_EXD_QUALIFIERS)17) +#define FIT_EXD_QUALIFIERS_PERCENT_MAXIMUM_AVERAGE ((FIT_EXD_QUALIFIERS)18) +#define FIT_EXD_QUALIFIERS_LAP_PERCENT_MAXIMUM ((FIT_EXD_QUALIFIERS)19) +#define FIT_EXD_QUALIFIERS_ELAPSED ((FIT_EXD_QUALIFIERS)20) +#define FIT_EXD_QUALIFIERS_SUNRISE ((FIT_EXD_QUALIFIERS)21) +#define FIT_EXD_QUALIFIERS_SUNSET ((FIT_EXD_QUALIFIERS)22) +#define FIT_EXD_QUALIFIERS_COMPARED_TO_VIRTUAL_PARTNER ((FIT_EXD_QUALIFIERS)23) +#define FIT_EXD_QUALIFIERS_MAXIMUM_24H ((FIT_EXD_QUALIFIERS)24) +#define FIT_EXD_QUALIFIERS_MINIMUM_24H ((FIT_EXD_QUALIFIERS)25) +#define FIT_EXD_QUALIFIERS_MINIMUM ((FIT_EXD_QUALIFIERS)26) +#define FIT_EXD_QUALIFIERS_FIRST ((FIT_EXD_QUALIFIERS)27) +#define FIT_EXD_QUALIFIERS_SECOND ((FIT_EXD_QUALIFIERS)28) +#define FIT_EXD_QUALIFIERS_THIRD ((FIT_EXD_QUALIFIERS)29) +#define FIT_EXD_QUALIFIERS_SHIFTER ((FIT_EXD_QUALIFIERS)30) +#define FIT_EXD_QUALIFIERS_LAST_SPORT ((FIT_EXD_QUALIFIERS)31) +#define FIT_EXD_QUALIFIERS_MOVING ((FIT_EXD_QUALIFIERS)32) +#define FIT_EXD_QUALIFIERS_STOPPED ((FIT_EXD_QUALIFIERS)33) +#define FIT_EXD_QUALIFIERS_ESTIMATED_TOTAL ((FIT_EXD_QUALIFIERS)34) +#define FIT_EXD_QUALIFIERS_ZONE_9 ((FIT_EXD_QUALIFIERS)242) +#define FIT_EXD_QUALIFIERS_ZONE_8 ((FIT_EXD_QUALIFIERS)243) +#define FIT_EXD_QUALIFIERS_ZONE_7 ((FIT_EXD_QUALIFIERS)244) +#define FIT_EXD_QUALIFIERS_ZONE_6 ((FIT_EXD_QUALIFIERS)245) +#define FIT_EXD_QUALIFIERS_ZONE_5 ((FIT_EXD_QUALIFIERS)246) +#define FIT_EXD_QUALIFIERS_ZONE_4 ((FIT_EXD_QUALIFIERS)247) +#define FIT_EXD_QUALIFIERS_ZONE_3 ((FIT_EXD_QUALIFIERS)248) +#define FIT_EXD_QUALIFIERS_ZONE_2 ((FIT_EXD_QUALIFIERS)249) +#define FIT_EXD_QUALIFIERS_ZONE_1 ((FIT_EXD_QUALIFIERS)250) +#define FIT_EXD_QUALIFIERS_COUNT 44 + +typedef FIT_ENUM FIT_EXD_DESCRIPTORS; +#define FIT_EXD_DESCRIPTORS_INVALID FIT_ENUM_INVALID +#define FIT_EXD_DESCRIPTORS_BIKE_LIGHT_BATTERY_STATUS ((FIT_EXD_DESCRIPTORS)0) +#define FIT_EXD_DESCRIPTORS_BEAM_ANGLE_STATUS ((FIT_EXD_DESCRIPTORS)1) +#define FIT_EXD_DESCRIPTORS_BATERY_LEVEL ((FIT_EXD_DESCRIPTORS)2) +#define FIT_EXD_DESCRIPTORS_LIGHT_NETWORK_MODE ((FIT_EXD_DESCRIPTORS)3) +#define FIT_EXD_DESCRIPTORS_NUMBER_LIGHTS_CONNECTED ((FIT_EXD_DESCRIPTORS)4) +#define FIT_EXD_DESCRIPTORS_CADENCE ((FIT_EXD_DESCRIPTORS)5) +#define FIT_EXD_DESCRIPTORS_DISTANCE ((FIT_EXD_DESCRIPTORS)6) +#define FIT_EXD_DESCRIPTORS_ESTIMATED_TIME_OF_ARRIVAL ((FIT_EXD_DESCRIPTORS)7) +#define FIT_EXD_DESCRIPTORS_HEADING ((FIT_EXD_DESCRIPTORS)8) +#define FIT_EXD_DESCRIPTORS_TIME ((FIT_EXD_DESCRIPTORS)9) +#define FIT_EXD_DESCRIPTORS_BATTERY_LEVEL ((FIT_EXD_DESCRIPTORS)10) +#define FIT_EXD_DESCRIPTORS_TRAINER_RESISTANCE ((FIT_EXD_DESCRIPTORS)11) +#define FIT_EXD_DESCRIPTORS_TRAINER_TARGET_POWER ((FIT_EXD_DESCRIPTORS)12) +#define FIT_EXD_DESCRIPTORS_TIME_SEATED ((FIT_EXD_DESCRIPTORS)13) +#define FIT_EXD_DESCRIPTORS_TIME_STANDING ((FIT_EXD_DESCRIPTORS)14) +#define FIT_EXD_DESCRIPTORS_ELEVATION ((FIT_EXD_DESCRIPTORS)15) +#define FIT_EXD_DESCRIPTORS_GRADE ((FIT_EXD_DESCRIPTORS)16) +#define FIT_EXD_DESCRIPTORS_ASCENT ((FIT_EXD_DESCRIPTORS)17) +#define FIT_EXD_DESCRIPTORS_DESCENT ((FIT_EXD_DESCRIPTORS)18) +#define FIT_EXD_DESCRIPTORS_VERTICAL_SPEED ((FIT_EXD_DESCRIPTORS)19) +#define FIT_EXD_DESCRIPTORS_DI2_BATTERY_LEVEL ((FIT_EXD_DESCRIPTORS)20) +#define FIT_EXD_DESCRIPTORS_FRONT_GEAR ((FIT_EXD_DESCRIPTORS)21) +#define FIT_EXD_DESCRIPTORS_REAR_GEAR ((FIT_EXD_DESCRIPTORS)22) +#define FIT_EXD_DESCRIPTORS_GEAR_RATIO ((FIT_EXD_DESCRIPTORS)23) +#define FIT_EXD_DESCRIPTORS_HEART_RATE ((FIT_EXD_DESCRIPTORS)24) +#define FIT_EXD_DESCRIPTORS_HEART_RATE_ZONE ((FIT_EXD_DESCRIPTORS)25) +#define FIT_EXD_DESCRIPTORS_TIME_IN_HEART_RATE_ZONE ((FIT_EXD_DESCRIPTORS)26) +#define FIT_EXD_DESCRIPTORS_HEART_RATE_RESERVE ((FIT_EXD_DESCRIPTORS)27) +#define FIT_EXD_DESCRIPTORS_CALORIES ((FIT_EXD_DESCRIPTORS)28) +#define FIT_EXD_DESCRIPTORS_GPS_ACCURACY ((FIT_EXD_DESCRIPTORS)29) +#define FIT_EXD_DESCRIPTORS_GPS_SIGNAL_STRENGTH ((FIT_EXD_DESCRIPTORS)30) +#define FIT_EXD_DESCRIPTORS_TEMPERATURE ((FIT_EXD_DESCRIPTORS)31) +#define FIT_EXD_DESCRIPTORS_TIME_OF_DAY ((FIT_EXD_DESCRIPTORS)32) +#define FIT_EXD_DESCRIPTORS_BALANCE ((FIT_EXD_DESCRIPTORS)33) +#define FIT_EXD_DESCRIPTORS_PEDAL_SMOOTHNESS ((FIT_EXD_DESCRIPTORS)34) +#define FIT_EXD_DESCRIPTORS_POWER ((FIT_EXD_DESCRIPTORS)35) +#define FIT_EXD_DESCRIPTORS_FUNCTIONAL_THRESHOLD_POWER ((FIT_EXD_DESCRIPTORS)36) +#define FIT_EXD_DESCRIPTORS_INTENSITY_FACTOR ((FIT_EXD_DESCRIPTORS)37) +#define FIT_EXD_DESCRIPTORS_WORK ((FIT_EXD_DESCRIPTORS)38) +#define FIT_EXD_DESCRIPTORS_POWER_RATIO ((FIT_EXD_DESCRIPTORS)39) +#define FIT_EXD_DESCRIPTORS_NORMALIZED_POWER ((FIT_EXD_DESCRIPTORS)40) +#define FIT_EXD_DESCRIPTORS_TRAINING_STRESS_SCORE ((FIT_EXD_DESCRIPTORS)41) +#define FIT_EXD_DESCRIPTORS_TIME_ON_ZONE ((FIT_EXD_DESCRIPTORS)42) +#define FIT_EXD_DESCRIPTORS_SPEED ((FIT_EXD_DESCRIPTORS)43) +#define FIT_EXD_DESCRIPTORS_LAPS ((FIT_EXD_DESCRIPTORS)44) +#define FIT_EXD_DESCRIPTORS_REPS ((FIT_EXD_DESCRIPTORS)45) +#define FIT_EXD_DESCRIPTORS_WORKOUT_STEP ((FIT_EXD_DESCRIPTORS)46) +#define FIT_EXD_DESCRIPTORS_COURSE_DISTANCE ((FIT_EXD_DESCRIPTORS)47) +#define FIT_EXD_DESCRIPTORS_NAVIGATION_DISTANCE ((FIT_EXD_DESCRIPTORS)48) +#define FIT_EXD_DESCRIPTORS_COURSE_ESTIMATED_TIME_OF_ARRIVAL ((FIT_EXD_DESCRIPTORS)49) +#define FIT_EXD_DESCRIPTORS_NAVIGATION_ESTIMATED_TIME_OF_ARRIVAL ((FIT_EXD_DESCRIPTORS)50) +#define FIT_EXD_DESCRIPTORS_COURSE_TIME ((FIT_EXD_DESCRIPTORS)51) +#define FIT_EXD_DESCRIPTORS_NAVIGATION_TIME ((FIT_EXD_DESCRIPTORS)52) +#define FIT_EXD_DESCRIPTORS_COURSE_HEADING ((FIT_EXD_DESCRIPTORS)53) +#define FIT_EXD_DESCRIPTORS_NAVIGATION_HEADING ((FIT_EXD_DESCRIPTORS)54) +#define FIT_EXD_DESCRIPTORS_POWER_ZONE ((FIT_EXD_DESCRIPTORS)55) +#define FIT_EXD_DESCRIPTORS_TORQUE_EFFECTIVENESS ((FIT_EXD_DESCRIPTORS)56) +#define FIT_EXD_DESCRIPTORS_TIMER_TIME ((FIT_EXD_DESCRIPTORS)57) +#define FIT_EXD_DESCRIPTORS_POWER_WEIGHT_RATIO ((FIT_EXD_DESCRIPTORS)58) +#define FIT_EXD_DESCRIPTORS_LEFT_PLATFORM_CENTER_OFFSET ((FIT_EXD_DESCRIPTORS)59) +#define FIT_EXD_DESCRIPTORS_RIGHT_PLATFORM_CENTER_OFFSET ((FIT_EXD_DESCRIPTORS)60) +#define FIT_EXD_DESCRIPTORS_LEFT_POWER_PHASE_START_ANGLE ((FIT_EXD_DESCRIPTORS)61) +#define FIT_EXD_DESCRIPTORS_RIGHT_POWER_PHASE_START_ANGLE ((FIT_EXD_DESCRIPTORS)62) +#define FIT_EXD_DESCRIPTORS_LEFT_POWER_PHASE_FINISH_ANGLE ((FIT_EXD_DESCRIPTORS)63) +#define FIT_EXD_DESCRIPTORS_RIGHT_POWER_PHASE_FINISH_ANGLE ((FIT_EXD_DESCRIPTORS)64) +#define FIT_EXD_DESCRIPTORS_GEARS ((FIT_EXD_DESCRIPTORS)65) // Combined gear information +#define FIT_EXD_DESCRIPTORS_PACE ((FIT_EXD_DESCRIPTORS)66) +#define FIT_EXD_DESCRIPTORS_TRAINING_EFFECT ((FIT_EXD_DESCRIPTORS)67) +#define FIT_EXD_DESCRIPTORS_VERTICAL_OSCILLATION ((FIT_EXD_DESCRIPTORS)68) +#define FIT_EXD_DESCRIPTORS_VERTICAL_RATIO ((FIT_EXD_DESCRIPTORS)69) +#define FIT_EXD_DESCRIPTORS_GROUND_CONTACT_TIME ((FIT_EXD_DESCRIPTORS)70) +#define FIT_EXD_DESCRIPTORS_LEFT_GROUND_CONTACT_TIME_BALANCE ((FIT_EXD_DESCRIPTORS)71) +#define FIT_EXD_DESCRIPTORS_RIGHT_GROUND_CONTACT_TIME_BALANCE ((FIT_EXD_DESCRIPTORS)72) +#define FIT_EXD_DESCRIPTORS_STRIDE_LENGTH ((FIT_EXD_DESCRIPTORS)73) +#define FIT_EXD_DESCRIPTORS_RUNNING_CADENCE ((FIT_EXD_DESCRIPTORS)74) +#define FIT_EXD_DESCRIPTORS_PERFORMANCE_CONDITION ((FIT_EXD_DESCRIPTORS)75) +#define FIT_EXD_DESCRIPTORS_COURSE_TYPE ((FIT_EXD_DESCRIPTORS)76) +#define FIT_EXD_DESCRIPTORS_TIME_IN_POWER_ZONE ((FIT_EXD_DESCRIPTORS)77) +#define FIT_EXD_DESCRIPTORS_NAVIGATION_TURN ((FIT_EXD_DESCRIPTORS)78) +#define FIT_EXD_DESCRIPTORS_COURSE_LOCATION ((FIT_EXD_DESCRIPTORS)79) +#define FIT_EXD_DESCRIPTORS_NAVIGATION_LOCATION ((FIT_EXD_DESCRIPTORS)80) +#define FIT_EXD_DESCRIPTORS_COMPASS ((FIT_EXD_DESCRIPTORS)81) +#define FIT_EXD_DESCRIPTORS_GEAR_COMBO ((FIT_EXD_DESCRIPTORS)82) +#define FIT_EXD_DESCRIPTORS_MUSCLE_OXYGEN ((FIT_EXD_DESCRIPTORS)83) +#define FIT_EXD_DESCRIPTORS_ICON ((FIT_EXD_DESCRIPTORS)84) +#define FIT_EXD_DESCRIPTORS_COMPASS_HEADING ((FIT_EXD_DESCRIPTORS)85) +#define FIT_EXD_DESCRIPTORS_GPS_HEADING ((FIT_EXD_DESCRIPTORS)86) +#define FIT_EXD_DESCRIPTORS_GPS_ELEVATION ((FIT_EXD_DESCRIPTORS)87) +#define FIT_EXD_DESCRIPTORS_ANAEROBIC_TRAINING_EFFECT ((FIT_EXD_DESCRIPTORS)88) +#define FIT_EXD_DESCRIPTORS_COURSE ((FIT_EXD_DESCRIPTORS)89) +#define FIT_EXD_DESCRIPTORS_OFF_COURSE ((FIT_EXD_DESCRIPTORS)90) +#define FIT_EXD_DESCRIPTORS_GLIDE_RATIO ((FIT_EXD_DESCRIPTORS)91) +#define FIT_EXD_DESCRIPTORS_VERTICAL_DISTANCE ((FIT_EXD_DESCRIPTORS)92) +#define FIT_EXD_DESCRIPTORS_VMG ((FIT_EXD_DESCRIPTORS)93) +#define FIT_EXD_DESCRIPTORS_AMBIENT_PRESSURE ((FIT_EXD_DESCRIPTORS)94) +#define FIT_EXD_DESCRIPTORS_PRESSURE ((FIT_EXD_DESCRIPTORS)95) +#define FIT_EXD_DESCRIPTORS_VAM ((FIT_EXD_DESCRIPTORS)96) +#define FIT_EXD_DESCRIPTORS_COUNT 97 + +typedef FIT_UINT32 FIT_AUTO_ACTIVITY_DETECT; +#define FIT_AUTO_ACTIVITY_DETECT_INVALID FIT_UINT32_INVALID +#define FIT_AUTO_ACTIVITY_DETECT_NONE ((FIT_AUTO_ACTIVITY_DETECT)0x00000000) +#define FIT_AUTO_ACTIVITY_DETECT_RUNNING ((FIT_AUTO_ACTIVITY_DETECT)0x00000001) +#define FIT_AUTO_ACTIVITY_DETECT_CYCLING ((FIT_AUTO_ACTIVITY_DETECT)0x00000002) +#define FIT_AUTO_ACTIVITY_DETECT_SWIMMING ((FIT_AUTO_ACTIVITY_DETECT)0x00000004) +#define FIT_AUTO_ACTIVITY_DETECT_WALKING ((FIT_AUTO_ACTIVITY_DETECT)0x00000008) +#define FIT_AUTO_ACTIVITY_DETECT_ELLIPTICAL ((FIT_AUTO_ACTIVITY_DETECT)0x00000020) +#define FIT_AUTO_ACTIVITY_DETECT_SEDENTARY ((FIT_AUTO_ACTIVITY_DETECT)0x00000400) +#define FIT_AUTO_ACTIVITY_DETECT_COUNT 7 + +typedef FIT_UINT32Z FIT_SUPPORTED_EXD_SCREEN_LAYOUTS; +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_INVALID FIT_UINT32Z_INVALID +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_FULL_SCREEN ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000001) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_HALF_VERTICAL ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000002) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_HALF_HORIZONTAL ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000004) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_HALF_VERTICAL_RIGHT_SPLIT ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000008) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_HALF_HORIZONTAL_BOTTOM_SPLIT ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000010) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_FULL_QUARTER_SPLIT ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000020) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_HALF_VERTICAL_LEFT_SPLIT ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000040) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_HALF_HORIZONTAL_TOP_SPLIT ((FIT_SUPPORTED_EXD_SCREEN_LAYOUTS)0x00000080) +#define FIT_SUPPORTED_EXD_SCREEN_LAYOUTS_COUNT 8 + +typedef FIT_UINT8 FIT_FIT_BASE_TYPE; +#define FIT_FIT_BASE_TYPE_INVALID FIT_UINT8_INVALID +#define FIT_FIT_BASE_TYPE_ENUM ((FIT_FIT_BASE_TYPE)0) +#define FIT_FIT_BASE_TYPE_SINT8 ((FIT_FIT_BASE_TYPE)1) +#define FIT_FIT_BASE_TYPE_UINT8 ((FIT_FIT_BASE_TYPE)2) +#define FIT_FIT_BASE_TYPE_SINT16 ((FIT_FIT_BASE_TYPE)131) +#define FIT_FIT_BASE_TYPE_UINT16 ((FIT_FIT_BASE_TYPE)132) +#define FIT_FIT_BASE_TYPE_SINT32 ((FIT_FIT_BASE_TYPE)133) +#define FIT_FIT_BASE_TYPE_UINT32 ((FIT_FIT_BASE_TYPE)134) +#define FIT_FIT_BASE_TYPE_STRING ((FIT_FIT_BASE_TYPE)7) +#define FIT_FIT_BASE_TYPE_FLOAT32 ((FIT_FIT_BASE_TYPE)136) +#define FIT_FIT_BASE_TYPE_FLOAT64 ((FIT_FIT_BASE_TYPE)137) +#define FIT_FIT_BASE_TYPE_UINT8Z ((FIT_FIT_BASE_TYPE)10) +#define FIT_FIT_BASE_TYPE_UINT16Z ((FIT_FIT_BASE_TYPE)139) +#define FIT_FIT_BASE_TYPE_UINT32Z ((FIT_FIT_BASE_TYPE)140) +#define FIT_FIT_BASE_TYPE_BYTE ((FIT_FIT_BASE_TYPE)13) +#define FIT_FIT_BASE_TYPE_SINT64 ((FIT_FIT_BASE_TYPE)142) +#define FIT_FIT_BASE_TYPE_UINT64 ((FIT_FIT_BASE_TYPE)143) +#define FIT_FIT_BASE_TYPE_UINT64Z ((FIT_FIT_BASE_TYPE)144) +#define FIT_FIT_BASE_TYPE_COUNT 17 + +typedef FIT_ENUM FIT_TURN_TYPE; +#define FIT_TURN_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_TURN_TYPE_ARRIVING_IDX ((FIT_TURN_TYPE)0) +#define FIT_TURN_TYPE_ARRIVING_LEFT_IDX ((FIT_TURN_TYPE)1) +#define FIT_TURN_TYPE_ARRIVING_RIGHT_IDX ((FIT_TURN_TYPE)2) +#define FIT_TURN_TYPE_ARRIVING_VIA_IDX ((FIT_TURN_TYPE)3) +#define FIT_TURN_TYPE_ARRIVING_VIA_LEFT_IDX ((FIT_TURN_TYPE)4) +#define FIT_TURN_TYPE_ARRIVING_VIA_RIGHT_IDX ((FIT_TURN_TYPE)5) +#define FIT_TURN_TYPE_BEAR_KEEP_LEFT_IDX ((FIT_TURN_TYPE)6) +#define FIT_TURN_TYPE_BEAR_KEEP_RIGHT_IDX ((FIT_TURN_TYPE)7) +#define FIT_TURN_TYPE_CONTINUE_IDX ((FIT_TURN_TYPE)8) +#define FIT_TURN_TYPE_EXIT_LEFT_IDX ((FIT_TURN_TYPE)9) +#define FIT_TURN_TYPE_EXIT_RIGHT_IDX ((FIT_TURN_TYPE)10) +#define FIT_TURN_TYPE_FERRY_IDX ((FIT_TURN_TYPE)11) +#define FIT_TURN_TYPE_ROUNDABOUT_45_IDX ((FIT_TURN_TYPE)12) +#define FIT_TURN_TYPE_ROUNDABOUT_90_IDX ((FIT_TURN_TYPE)13) +#define FIT_TURN_TYPE_ROUNDABOUT_135_IDX ((FIT_TURN_TYPE)14) +#define FIT_TURN_TYPE_ROUNDABOUT_180_IDX ((FIT_TURN_TYPE)15) +#define FIT_TURN_TYPE_ROUNDABOUT_225_IDX ((FIT_TURN_TYPE)16) +#define FIT_TURN_TYPE_ROUNDABOUT_270_IDX ((FIT_TURN_TYPE)17) +#define FIT_TURN_TYPE_ROUNDABOUT_315_IDX ((FIT_TURN_TYPE)18) +#define FIT_TURN_TYPE_ROUNDABOUT_360_IDX ((FIT_TURN_TYPE)19) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_45_IDX ((FIT_TURN_TYPE)20) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_90_IDX ((FIT_TURN_TYPE)21) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_135_IDX ((FIT_TURN_TYPE)22) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_180_IDX ((FIT_TURN_TYPE)23) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_225_IDX ((FIT_TURN_TYPE)24) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_270_IDX ((FIT_TURN_TYPE)25) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_315_IDX ((FIT_TURN_TYPE)26) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_360_IDX ((FIT_TURN_TYPE)27) +#define FIT_TURN_TYPE_ROUNDABOUT_GENERIC_IDX ((FIT_TURN_TYPE)28) +#define FIT_TURN_TYPE_ROUNDABOUT_NEG_GENERIC_IDX ((FIT_TURN_TYPE)29) +#define FIT_TURN_TYPE_SHARP_TURN_LEFT_IDX ((FIT_TURN_TYPE)30) +#define FIT_TURN_TYPE_SHARP_TURN_RIGHT_IDX ((FIT_TURN_TYPE)31) +#define FIT_TURN_TYPE_TURN_LEFT_IDX ((FIT_TURN_TYPE)32) +#define FIT_TURN_TYPE_TURN_RIGHT_IDX ((FIT_TURN_TYPE)33) +#define FIT_TURN_TYPE_UTURN_LEFT_IDX ((FIT_TURN_TYPE)34) +#define FIT_TURN_TYPE_UTURN_RIGHT_IDX ((FIT_TURN_TYPE)35) +#define FIT_TURN_TYPE_ICON_INV_IDX ((FIT_TURN_TYPE)36) +#define FIT_TURN_TYPE_ICON_IDX_CNT ((FIT_TURN_TYPE)37) +#define FIT_TURN_TYPE_COUNT 38 + +typedef FIT_UINT8 FIT_BIKE_LIGHT_BEAM_ANGLE_MODE; +#define FIT_BIKE_LIGHT_BEAM_ANGLE_MODE_INVALID FIT_UINT8_INVALID +#define FIT_BIKE_LIGHT_BEAM_ANGLE_MODE_MANUAL ((FIT_BIKE_LIGHT_BEAM_ANGLE_MODE)0) +#define FIT_BIKE_LIGHT_BEAM_ANGLE_MODE_AUTO ((FIT_BIKE_LIGHT_BEAM_ANGLE_MODE)1) +#define FIT_BIKE_LIGHT_BEAM_ANGLE_MODE_COUNT 2 + +typedef FIT_UINT16 FIT_FIT_BASE_UNIT; +#define FIT_FIT_BASE_UNIT_INVALID FIT_UINT16_INVALID +#define FIT_FIT_BASE_UNIT_OTHER ((FIT_FIT_BASE_UNIT)0) +#define FIT_FIT_BASE_UNIT_KILOGRAM ((FIT_FIT_BASE_UNIT)1) +#define FIT_FIT_BASE_UNIT_POUND ((FIT_FIT_BASE_UNIT)2) +#define FIT_FIT_BASE_UNIT_COUNT 3 + +typedef FIT_UINT8 FIT_SET_TYPE; +#define FIT_SET_TYPE_INVALID FIT_UINT8_INVALID +#define FIT_SET_TYPE_REST ((FIT_SET_TYPE)0) +#define FIT_SET_TYPE_ACTIVE ((FIT_SET_TYPE)1) +#define FIT_SET_TYPE_COUNT 2 + +typedef FIT_ENUM FIT_MAX_MET_CATEGORY; +#define FIT_MAX_MET_CATEGORY_INVALID FIT_ENUM_INVALID +#define FIT_MAX_MET_CATEGORY_GENERIC ((FIT_MAX_MET_CATEGORY)0) +#define FIT_MAX_MET_CATEGORY_CYCLING ((FIT_MAX_MET_CATEGORY)1) +#define FIT_MAX_MET_CATEGORY_COUNT 2 + +typedef FIT_UINT16 FIT_EXERCISE_CATEGORY; +#define FIT_EXERCISE_CATEGORY_INVALID FIT_UINT16_INVALID +#define FIT_EXERCISE_CATEGORY_BENCH_PRESS ((FIT_EXERCISE_CATEGORY)0) +#define FIT_EXERCISE_CATEGORY_CALF_RAISE ((FIT_EXERCISE_CATEGORY)1) +#define FIT_EXERCISE_CATEGORY_CARDIO ((FIT_EXERCISE_CATEGORY)2) +#define FIT_EXERCISE_CATEGORY_CARRY ((FIT_EXERCISE_CATEGORY)3) +#define FIT_EXERCISE_CATEGORY_CHOP ((FIT_EXERCISE_CATEGORY)4) +#define FIT_EXERCISE_CATEGORY_CORE ((FIT_EXERCISE_CATEGORY)5) +#define FIT_EXERCISE_CATEGORY_CRUNCH ((FIT_EXERCISE_CATEGORY)6) +#define FIT_EXERCISE_CATEGORY_CURL ((FIT_EXERCISE_CATEGORY)7) +#define FIT_EXERCISE_CATEGORY_DEADLIFT ((FIT_EXERCISE_CATEGORY)8) +#define FIT_EXERCISE_CATEGORY_FLYE ((FIT_EXERCISE_CATEGORY)9) +#define FIT_EXERCISE_CATEGORY_HIP_RAISE ((FIT_EXERCISE_CATEGORY)10) +#define FIT_EXERCISE_CATEGORY_HIP_STABILITY ((FIT_EXERCISE_CATEGORY)11) +#define FIT_EXERCISE_CATEGORY_HIP_SWING ((FIT_EXERCISE_CATEGORY)12) +#define FIT_EXERCISE_CATEGORY_HYPEREXTENSION ((FIT_EXERCISE_CATEGORY)13) +#define FIT_EXERCISE_CATEGORY_LATERAL_RAISE ((FIT_EXERCISE_CATEGORY)14) +#define FIT_EXERCISE_CATEGORY_LEG_CURL ((FIT_EXERCISE_CATEGORY)15) +#define FIT_EXERCISE_CATEGORY_LEG_RAISE ((FIT_EXERCISE_CATEGORY)16) +#define FIT_EXERCISE_CATEGORY_LUNGE ((FIT_EXERCISE_CATEGORY)17) +#define FIT_EXERCISE_CATEGORY_OLYMPIC_LIFT ((FIT_EXERCISE_CATEGORY)18) +#define FIT_EXERCISE_CATEGORY_PLANK ((FIT_EXERCISE_CATEGORY)19) +#define FIT_EXERCISE_CATEGORY_PLYO ((FIT_EXERCISE_CATEGORY)20) +#define FIT_EXERCISE_CATEGORY_PULL_UP ((FIT_EXERCISE_CATEGORY)21) +#define FIT_EXERCISE_CATEGORY_PUSH_UP ((FIT_EXERCISE_CATEGORY)22) +#define FIT_EXERCISE_CATEGORY_ROW ((FIT_EXERCISE_CATEGORY)23) +#define FIT_EXERCISE_CATEGORY_SHOULDER_PRESS ((FIT_EXERCISE_CATEGORY)24) +#define FIT_EXERCISE_CATEGORY_SHOULDER_STABILITY ((FIT_EXERCISE_CATEGORY)25) +#define FIT_EXERCISE_CATEGORY_SHRUG ((FIT_EXERCISE_CATEGORY)26) +#define FIT_EXERCISE_CATEGORY_SIT_UP ((FIT_EXERCISE_CATEGORY)27) +#define FIT_EXERCISE_CATEGORY_SQUAT ((FIT_EXERCISE_CATEGORY)28) +#define FIT_EXERCISE_CATEGORY_TOTAL_BODY ((FIT_EXERCISE_CATEGORY)29) +#define FIT_EXERCISE_CATEGORY_TRICEPS_EXTENSION ((FIT_EXERCISE_CATEGORY)30) +#define FIT_EXERCISE_CATEGORY_WARM_UP ((FIT_EXERCISE_CATEGORY)31) +#define FIT_EXERCISE_CATEGORY_RUN ((FIT_EXERCISE_CATEGORY)32) +#define FIT_EXERCISE_CATEGORY_BIKE ((FIT_EXERCISE_CATEGORY)33) +#define FIT_EXERCISE_CATEGORY_CARDIO_SENSORS ((FIT_EXERCISE_CATEGORY)34) // Exercises within workouts that use GPS/sensors rather than rep counting +#define FIT_EXERCISE_CATEGORY_MOVE ((FIT_EXERCISE_CATEGORY)35) +#define FIT_EXERCISE_CATEGORY_POSE ((FIT_EXERCISE_CATEGORY)36) +#define FIT_EXERCISE_CATEGORY_BANDED_EXERCISES ((FIT_EXERCISE_CATEGORY)37) +#define FIT_EXERCISE_CATEGORY_BATTLE_ROPE ((FIT_EXERCISE_CATEGORY)38) +#define FIT_EXERCISE_CATEGORY_ELLIPTICAL ((FIT_EXERCISE_CATEGORY)39) +#define FIT_EXERCISE_CATEGORY_FLOOR_CLIMB ((FIT_EXERCISE_CATEGORY)40) +#define FIT_EXERCISE_CATEGORY_INDOOR_BIKE ((FIT_EXERCISE_CATEGORY)41) +#define FIT_EXERCISE_CATEGORY_INDOOR_ROW ((FIT_EXERCISE_CATEGORY)42) +#define FIT_EXERCISE_CATEGORY_LADDER ((FIT_EXERCISE_CATEGORY)43) +#define FIT_EXERCISE_CATEGORY_SANDBAG ((FIT_EXERCISE_CATEGORY)44) +#define FIT_EXERCISE_CATEGORY_SLED ((FIT_EXERCISE_CATEGORY)45) +#define FIT_EXERCISE_CATEGORY_SLEDGE_HAMMER ((FIT_EXERCISE_CATEGORY)46) +#define FIT_EXERCISE_CATEGORY_STAIR_STEPPER ((FIT_EXERCISE_CATEGORY)47) +#define FIT_EXERCISE_CATEGORY_SUSPENSION ((FIT_EXERCISE_CATEGORY)49) +#define FIT_EXERCISE_CATEGORY_TIRE ((FIT_EXERCISE_CATEGORY)50) +#define FIT_EXERCISE_CATEGORY_RUN_INDOOR ((FIT_EXERCISE_CATEGORY)52) +#define FIT_EXERCISE_CATEGORY_BIKE_OUTDOOR ((FIT_EXERCISE_CATEGORY)53) +#define FIT_EXERCISE_CATEGORY_UNKNOWN ((FIT_EXERCISE_CATEGORY)65534) +#define FIT_EXERCISE_CATEGORY_COUNT 53 + +typedef FIT_UINT16 FIT_BENCH_PRESS_EXERCISE_NAME; +#define FIT_BENCH_PRESS_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_BENCH_PRESS_EXERCISE_NAME_ALTERNATING_DUMBBELL_CHEST_PRESS_ON_SWISS_BALL ((FIT_BENCH_PRESS_EXERCISE_NAME)0) +#define FIT_BENCH_PRESS_EXERCISE_NAME_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)1) +#define FIT_BENCH_PRESS_EXERCISE_NAME_BARBELL_BOARD_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)2) +#define FIT_BENCH_PRESS_EXERCISE_NAME_BARBELL_FLOOR_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)3) +#define FIT_BENCH_PRESS_EXERCISE_NAME_CLOSE_GRIP_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)4) +#define FIT_BENCH_PRESS_EXERCISE_NAME_DECLINE_DUMBBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)5) +#define FIT_BENCH_PRESS_EXERCISE_NAME_DUMBBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)6) +#define FIT_BENCH_PRESS_EXERCISE_NAME_DUMBBELL_FLOOR_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)7) +#define FIT_BENCH_PRESS_EXERCISE_NAME_INCLINE_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)8) +#define FIT_BENCH_PRESS_EXERCISE_NAME_INCLINE_DUMBBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)9) +#define FIT_BENCH_PRESS_EXERCISE_NAME_INCLINE_SMITH_MACHINE_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)10) +#define FIT_BENCH_PRESS_EXERCISE_NAME_ISOMETRIC_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)11) +#define FIT_BENCH_PRESS_EXERCISE_NAME_KETTLEBELL_CHEST_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)12) +#define FIT_BENCH_PRESS_EXERCISE_NAME_NEUTRAL_GRIP_DUMBBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)13) +#define FIT_BENCH_PRESS_EXERCISE_NAME_NEUTRAL_GRIP_DUMBBELL_INCLINE_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)14) +#define FIT_BENCH_PRESS_EXERCISE_NAME_ONE_ARM_FLOOR_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)15) +#define FIT_BENCH_PRESS_EXERCISE_NAME_WEIGHTED_ONE_ARM_FLOOR_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)16) +#define FIT_BENCH_PRESS_EXERCISE_NAME_PARTIAL_LOCKOUT ((FIT_BENCH_PRESS_EXERCISE_NAME)17) +#define FIT_BENCH_PRESS_EXERCISE_NAME_REVERSE_GRIP_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)18) +#define FIT_BENCH_PRESS_EXERCISE_NAME_REVERSE_GRIP_INCLINE_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)19) +#define FIT_BENCH_PRESS_EXERCISE_NAME_SINGLE_ARM_CABLE_CHEST_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)20) +#define FIT_BENCH_PRESS_EXERCISE_NAME_SINGLE_ARM_DUMBBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)21) +#define FIT_BENCH_PRESS_EXERCISE_NAME_SMITH_MACHINE_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)22) +#define FIT_BENCH_PRESS_EXERCISE_NAME_SWISS_BALL_DUMBBELL_CHEST_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)23) +#define FIT_BENCH_PRESS_EXERCISE_NAME_TRIPLE_STOP_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)24) +#define FIT_BENCH_PRESS_EXERCISE_NAME_WIDE_GRIP_BARBELL_BENCH_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)25) +#define FIT_BENCH_PRESS_EXERCISE_NAME_ALTERNATING_DUMBBELL_CHEST_PRESS ((FIT_BENCH_PRESS_EXERCISE_NAME)26) +#define FIT_BENCH_PRESS_EXERCISE_NAME_COUNT 27 + +typedef FIT_UINT16 FIT_CALF_RAISE_EXERCISE_NAME; +#define FIT_CALF_RAISE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CALF_RAISE_EXERCISE_NAME_3_WAY_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)0) +#define FIT_CALF_RAISE_EXERCISE_NAME_3_WAY_WEIGHTED_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)1) +#define FIT_CALF_RAISE_EXERCISE_NAME_3_WAY_SINGLE_LEG_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)2) +#define FIT_CALF_RAISE_EXERCISE_NAME_3_WAY_WEIGHTED_SINGLE_LEG_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)3) +#define FIT_CALF_RAISE_EXERCISE_NAME_DONKEY_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)4) +#define FIT_CALF_RAISE_EXERCISE_NAME_WEIGHTED_DONKEY_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)5) +#define FIT_CALF_RAISE_EXERCISE_NAME_SEATED_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)6) +#define FIT_CALF_RAISE_EXERCISE_NAME_WEIGHTED_SEATED_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)7) +#define FIT_CALF_RAISE_EXERCISE_NAME_SEATED_DUMBBELL_TOE_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)8) +#define FIT_CALF_RAISE_EXERCISE_NAME_SINGLE_LEG_BENT_KNEE_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)9) +#define FIT_CALF_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_BENT_KNEE_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)10) +#define FIT_CALF_RAISE_EXERCISE_NAME_SINGLE_LEG_DECLINE_PUSH_UP ((FIT_CALF_RAISE_EXERCISE_NAME)11) +#define FIT_CALF_RAISE_EXERCISE_NAME_SINGLE_LEG_DONKEY_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)12) +#define FIT_CALF_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_DONKEY_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)13) +#define FIT_CALF_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE_WITH_KNEE_HOLD ((FIT_CALF_RAISE_EXERCISE_NAME)14) +#define FIT_CALF_RAISE_EXERCISE_NAME_SINGLE_LEG_STANDING_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)15) +#define FIT_CALF_RAISE_EXERCISE_NAME_SINGLE_LEG_STANDING_DUMBBELL_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)16) +#define FIT_CALF_RAISE_EXERCISE_NAME_STANDING_BARBELL_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)17) +#define FIT_CALF_RAISE_EXERCISE_NAME_STANDING_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)18) +#define FIT_CALF_RAISE_EXERCISE_NAME_WEIGHTED_STANDING_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)19) +#define FIT_CALF_RAISE_EXERCISE_NAME_STANDING_DUMBBELL_CALF_RAISE ((FIT_CALF_RAISE_EXERCISE_NAME)20) +#define FIT_CALF_RAISE_EXERCISE_NAME_COUNT 21 + +typedef FIT_UINT16 FIT_CARDIO_EXERCISE_NAME; +#define FIT_CARDIO_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CARDIO_EXERCISE_NAME_BOB_AND_WEAVE_CIRCLE ((FIT_CARDIO_EXERCISE_NAME)0) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_BOB_AND_WEAVE_CIRCLE ((FIT_CARDIO_EXERCISE_NAME)1) +#define FIT_CARDIO_EXERCISE_NAME_CARDIO_CORE_CRAWL ((FIT_CARDIO_EXERCISE_NAME)2) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_CARDIO_CORE_CRAWL ((FIT_CARDIO_EXERCISE_NAME)3) +#define FIT_CARDIO_EXERCISE_NAME_DOUBLE_UNDER ((FIT_CARDIO_EXERCISE_NAME)4) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_DOUBLE_UNDER ((FIT_CARDIO_EXERCISE_NAME)5) +#define FIT_CARDIO_EXERCISE_NAME_JUMP_ROPE ((FIT_CARDIO_EXERCISE_NAME)6) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_JUMP_ROPE ((FIT_CARDIO_EXERCISE_NAME)7) +#define FIT_CARDIO_EXERCISE_NAME_JUMP_ROPE_CROSSOVER ((FIT_CARDIO_EXERCISE_NAME)8) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_JUMP_ROPE_CROSSOVER ((FIT_CARDIO_EXERCISE_NAME)9) +#define FIT_CARDIO_EXERCISE_NAME_JUMP_ROPE_JOG ((FIT_CARDIO_EXERCISE_NAME)10) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_JUMP_ROPE_JOG ((FIT_CARDIO_EXERCISE_NAME)11) +#define FIT_CARDIO_EXERCISE_NAME_JUMPING_JACKS ((FIT_CARDIO_EXERCISE_NAME)12) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_JUMPING_JACKS ((FIT_CARDIO_EXERCISE_NAME)13) +#define FIT_CARDIO_EXERCISE_NAME_SKI_MOGULS ((FIT_CARDIO_EXERCISE_NAME)14) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_SKI_MOGULS ((FIT_CARDIO_EXERCISE_NAME)15) +#define FIT_CARDIO_EXERCISE_NAME_SPLIT_JACKS ((FIT_CARDIO_EXERCISE_NAME)16) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_SPLIT_JACKS ((FIT_CARDIO_EXERCISE_NAME)17) +#define FIT_CARDIO_EXERCISE_NAME_SQUAT_JACKS ((FIT_CARDIO_EXERCISE_NAME)18) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_SQUAT_JACKS ((FIT_CARDIO_EXERCISE_NAME)19) +#define FIT_CARDIO_EXERCISE_NAME_TRIPLE_UNDER ((FIT_CARDIO_EXERCISE_NAME)20) +#define FIT_CARDIO_EXERCISE_NAME_WEIGHTED_TRIPLE_UNDER ((FIT_CARDIO_EXERCISE_NAME)21) +#define FIT_CARDIO_EXERCISE_NAME_ELLIPTICAL ((FIT_CARDIO_EXERCISE_NAME)22) +#define FIT_CARDIO_EXERCISE_NAME_SPINNING ((FIT_CARDIO_EXERCISE_NAME)23) +#define FIT_CARDIO_EXERCISE_NAME_POLE_PADDLE_FORWARD_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)24) +#define FIT_CARDIO_EXERCISE_NAME_POLE_PADDLE_BACKWARD_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)25) +#define FIT_CARDIO_EXERCISE_NAME_POLE_HANDCYCLE_FORWARD_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)26) +#define FIT_CARDIO_EXERCISE_NAME_POLE_HANDCYCLE_BACKWARD_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)27) +#define FIT_CARDIO_EXERCISE_NAME_POLE_RAINBOW_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)28) +#define FIT_CARDIO_EXERCISE_NAME_DOUBLE_PUNCH_FORWARD_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)29) +#define FIT_CARDIO_EXERCISE_NAME_DOUBLE_PUNCH_DOWN_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)30) +#define FIT_CARDIO_EXERCISE_NAME_DOUBLE_PUNCH_SIDEWAYS_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)31) +#define FIT_CARDIO_EXERCISE_NAME_DOUBLE_PUNCH_UP_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)32) +#define FIT_CARDIO_EXERCISE_NAME_SIT_SKI_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)33) +#define FIT_CARDIO_EXERCISE_NAME_SITTING_JACKS_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)34) +#define FIT_CARDIO_EXERCISE_NAME_PUNCH_FORWARD_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)35) +#define FIT_CARDIO_EXERCISE_NAME_PUNCH_DOWN_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)36) +#define FIT_CARDIO_EXERCISE_NAME_PUNCH_SIDEWAYS_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)37) +#define FIT_CARDIO_EXERCISE_NAME_PUNCH_UP_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)38) +#define FIT_CARDIO_EXERCISE_NAME_PUNCH_BAG_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)39) +#define FIT_CARDIO_EXERCISE_NAME_POLE_DD_FF_UU_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)40) +#define FIT_CARDIO_EXERCISE_NAME_BUTTERFLY_ARMS_WHEELCHAIR ((FIT_CARDIO_EXERCISE_NAME)41) +#define FIT_CARDIO_EXERCISE_NAME_PUNCH ((FIT_CARDIO_EXERCISE_NAME)42) +#define FIT_CARDIO_EXERCISE_NAME_COUNT 43 + +typedef FIT_UINT16 FIT_CARRY_EXERCISE_NAME; +#define FIT_CARRY_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CARRY_EXERCISE_NAME_BAR_HOLDS ((FIT_CARRY_EXERCISE_NAME)0) +#define FIT_CARRY_EXERCISE_NAME_FARMERS_WALK ((FIT_CARRY_EXERCISE_NAME)1) +#define FIT_CARRY_EXERCISE_NAME_FARMERS_WALK_ON_TOES ((FIT_CARRY_EXERCISE_NAME)2) +#define FIT_CARRY_EXERCISE_NAME_HEX_DUMBBELL_HOLD ((FIT_CARRY_EXERCISE_NAME)3) +#define FIT_CARRY_EXERCISE_NAME_OVERHEAD_CARRY ((FIT_CARRY_EXERCISE_NAME)4) +#define FIT_CARRY_EXERCISE_NAME_DUMBBELL_WAITER_CARRY ((FIT_CARRY_EXERCISE_NAME)5) +#define FIT_CARRY_EXERCISE_NAME_FARMERS_CARRY_WALK_LUNGE ((FIT_CARRY_EXERCISE_NAME)6) +#define FIT_CARRY_EXERCISE_NAME_FARMERS_CARRY ((FIT_CARRY_EXERCISE_NAME)7) +#define FIT_CARRY_EXERCISE_NAME_FARMERS_CARRY_ON_TOES ((FIT_CARRY_EXERCISE_NAME)8) +#define FIT_CARRY_EXERCISE_NAME_COUNT 9 + +typedef FIT_UINT16 FIT_CHOP_EXERCISE_NAME; +#define FIT_CHOP_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CHOP_EXERCISE_NAME_CABLE_PULL_THROUGH ((FIT_CHOP_EXERCISE_NAME)0) +#define FIT_CHOP_EXERCISE_NAME_CABLE_ROTATIONAL_LIFT ((FIT_CHOP_EXERCISE_NAME)1) +#define FIT_CHOP_EXERCISE_NAME_CABLE_WOODCHOP ((FIT_CHOP_EXERCISE_NAME)2) +#define FIT_CHOP_EXERCISE_NAME_CROSS_CHOP_TO_KNEE ((FIT_CHOP_EXERCISE_NAME)3) +#define FIT_CHOP_EXERCISE_NAME_WEIGHTED_CROSS_CHOP_TO_KNEE ((FIT_CHOP_EXERCISE_NAME)4) +#define FIT_CHOP_EXERCISE_NAME_DUMBBELL_CHOP ((FIT_CHOP_EXERCISE_NAME)5) +#define FIT_CHOP_EXERCISE_NAME_HALF_KNEELING_ROTATION ((FIT_CHOP_EXERCISE_NAME)6) +#define FIT_CHOP_EXERCISE_NAME_WEIGHTED_HALF_KNEELING_ROTATION ((FIT_CHOP_EXERCISE_NAME)7) +#define FIT_CHOP_EXERCISE_NAME_HALF_KNEELING_ROTATIONAL_CHOP ((FIT_CHOP_EXERCISE_NAME)8) +#define FIT_CHOP_EXERCISE_NAME_HALF_KNEELING_ROTATIONAL_REVERSE_CHOP ((FIT_CHOP_EXERCISE_NAME)9) +#define FIT_CHOP_EXERCISE_NAME_HALF_KNEELING_STABILITY_CHOP ((FIT_CHOP_EXERCISE_NAME)10) +#define FIT_CHOP_EXERCISE_NAME_HALF_KNEELING_STABILITY_REVERSE_CHOP ((FIT_CHOP_EXERCISE_NAME)11) +#define FIT_CHOP_EXERCISE_NAME_KNEELING_ROTATIONAL_CHOP ((FIT_CHOP_EXERCISE_NAME)12) +#define FIT_CHOP_EXERCISE_NAME_KNEELING_ROTATIONAL_REVERSE_CHOP ((FIT_CHOP_EXERCISE_NAME)13) +#define FIT_CHOP_EXERCISE_NAME_KNEELING_STABILITY_CHOP ((FIT_CHOP_EXERCISE_NAME)14) +#define FIT_CHOP_EXERCISE_NAME_KNEELING_WOODCHOPPER ((FIT_CHOP_EXERCISE_NAME)15) +#define FIT_CHOP_EXERCISE_NAME_MEDICINE_BALL_WOOD_CHOPS ((FIT_CHOP_EXERCISE_NAME)16) +#define FIT_CHOP_EXERCISE_NAME_POWER_SQUAT_CHOPS ((FIT_CHOP_EXERCISE_NAME)17) +#define FIT_CHOP_EXERCISE_NAME_WEIGHTED_POWER_SQUAT_CHOPS ((FIT_CHOP_EXERCISE_NAME)18) +#define FIT_CHOP_EXERCISE_NAME_STANDING_ROTATIONAL_CHOP ((FIT_CHOP_EXERCISE_NAME)19) +#define FIT_CHOP_EXERCISE_NAME_STANDING_SPLIT_ROTATIONAL_CHOP ((FIT_CHOP_EXERCISE_NAME)20) +#define FIT_CHOP_EXERCISE_NAME_STANDING_SPLIT_ROTATIONAL_REVERSE_CHOP ((FIT_CHOP_EXERCISE_NAME)21) +#define FIT_CHOP_EXERCISE_NAME_STANDING_STABILITY_REVERSE_CHOP ((FIT_CHOP_EXERCISE_NAME)22) +#define FIT_CHOP_EXERCISE_NAME_COUNT 23 + +typedef FIT_UINT16 FIT_CORE_EXERCISE_NAME; +#define FIT_CORE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CORE_EXERCISE_NAME_ABS_JABS ((FIT_CORE_EXERCISE_NAME)0) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_ABS_JABS ((FIT_CORE_EXERCISE_NAME)1) +#define FIT_CORE_EXERCISE_NAME_ALTERNATING_PLATE_REACH ((FIT_CORE_EXERCISE_NAME)2) +#define FIT_CORE_EXERCISE_NAME_BARBELL_ROLLOUT ((FIT_CORE_EXERCISE_NAME)3) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_BARBELL_ROLLOUT ((FIT_CORE_EXERCISE_NAME)4) +#define FIT_CORE_EXERCISE_NAME_BODY_BAR_OBLIQUE_TWIST ((FIT_CORE_EXERCISE_NAME)5) +#define FIT_CORE_EXERCISE_NAME_CABLE_CORE_PRESS ((FIT_CORE_EXERCISE_NAME)6) +#define FIT_CORE_EXERCISE_NAME_CABLE_SIDE_BEND ((FIT_CORE_EXERCISE_NAME)7) +#define FIT_CORE_EXERCISE_NAME_SIDE_BEND ((FIT_CORE_EXERCISE_NAME)8) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_SIDE_BEND ((FIT_CORE_EXERCISE_NAME)9) +#define FIT_CORE_EXERCISE_NAME_CRESCENT_CIRCLE ((FIT_CORE_EXERCISE_NAME)10) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_CRESCENT_CIRCLE ((FIT_CORE_EXERCISE_NAME)11) +#define FIT_CORE_EXERCISE_NAME_CYCLING_RUSSIAN_TWIST ((FIT_CORE_EXERCISE_NAME)12) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_CYCLING_RUSSIAN_TWIST ((FIT_CORE_EXERCISE_NAME)13) +#define FIT_CORE_EXERCISE_NAME_ELEVATED_FEET_RUSSIAN_TWIST ((FIT_CORE_EXERCISE_NAME)14) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_ELEVATED_FEET_RUSSIAN_TWIST ((FIT_CORE_EXERCISE_NAME)15) +#define FIT_CORE_EXERCISE_NAME_HALF_TURKISH_GET_UP ((FIT_CORE_EXERCISE_NAME)16) +#define FIT_CORE_EXERCISE_NAME_KETTLEBELL_WINDMILL ((FIT_CORE_EXERCISE_NAME)17) +#define FIT_CORE_EXERCISE_NAME_KNEELING_AB_WHEEL ((FIT_CORE_EXERCISE_NAME)18) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_KNEELING_AB_WHEEL ((FIT_CORE_EXERCISE_NAME)19) +#define FIT_CORE_EXERCISE_NAME_MODIFIED_FRONT_LEVER ((FIT_CORE_EXERCISE_NAME)20) +#define FIT_CORE_EXERCISE_NAME_OPEN_KNEE_TUCKS ((FIT_CORE_EXERCISE_NAME)21) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_OPEN_KNEE_TUCKS ((FIT_CORE_EXERCISE_NAME)22) +#define FIT_CORE_EXERCISE_NAME_SIDE_ABS_LEG_LIFT ((FIT_CORE_EXERCISE_NAME)23) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_SIDE_ABS_LEG_LIFT ((FIT_CORE_EXERCISE_NAME)24) +#define FIT_CORE_EXERCISE_NAME_SWISS_BALL_JACKKNIFE ((FIT_CORE_EXERCISE_NAME)25) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_SWISS_BALL_JACKKNIFE ((FIT_CORE_EXERCISE_NAME)26) +#define FIT_CORE_EXERCISE_NAME_SWISS_BALL_PIKE ((FIT_CORE_EXERCISE_NAME)27) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PIKE ((FIT_CORE_EXERCISE_NAME)28) +#define FIT_CORE_EXERCISE_NAME_SWISS_BALL_ROLLOUT ((FIT_CORE_EXERCISE_NAME)29) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_SWISS_BALL_ROLLOUT ((FIT_CORE_EXERCISE_NAME)30) +#define FIT_CORE_EXERCISE_NAME_TRIANGLE_HIP_PRESS ((FIT_CORE_EXERCISE_NAME)31) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_TRIANGLE_HIP_PRESS ((FIT_CORE_EXERCISE_NAME)32) +#define FIT_CORE_EXERCISE_NAME_TRX_SUSPENDED_JACKKNIFE ((FIT_CORE_EXERCISE_NAME)33) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_TRX_SUSPENDED_JACKKNIFE ((FIT_CORE_EXERCISE_NAME)34) +#define FIT_CORE_EXERCISE_NAME_U_BOAT ((FIT_CORE_EXERCISE_NAME)35) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_U_BOAT ((FIT_CORE_EXERCISE_NAME)36) +#define FIT_CORE_EXERCISE_NAME_WINDMILL_SWITCHES ((FIT_CORE_EXERCISE_NAME)37) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_WINDMILL_SWITCHES ((FIT_CORE_EXERCISE_NAME)38) +#define FIT_CORE_EXERCISE_NAME_ALTERNATING_SLIDE_OUT ((FIT_CORE_EXERCISE_NAME)39) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_ALTERNATING_SLIDE_OUT ((FIT_CORE_EXERCISE_NAME)40) +#define FIT_CORE_EXERCISE_NAME_GHD_BACK_EXTENSIONS ((FIT_CORE_EXERCISE_NAME)41) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_GHD_BACK_EXTENSIONS ((FIT_CORE_EXERCISE_NAME)42) +#define FIT_CORE_EXERCISE_NAME_OVERHEAD_WALK ((FIT_CORE_EXERCISE_NAME)43) +#define FIT_CORE_EXERCISE_NAME_INCHWORM ((FIT_CORE_EXERCISE_NAME)44) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_MODIFIED_FRONT_LEVER ((FIT_CORE_EXERCISE_NAME)45) +#define FIT_CORE_EXERCISE_NAME_RUSSIAN_TWIST ((FIT_CORE_EXERCISE_NAME)46) +#define FIT_CORE_EXERCISE_NAME_ABDOMINAL_LEG_ROTATIONS ((FIT_CORE_EXERCISE_NAME)47) // Deprecated do not use +#define FIT_CORE_EXERCISE_NAME_ARM_AND_LEG_EXTENSION_ON_KNEES ((FIT_CORE_EXERCISE_NAME)48) +#define FIT_CORE_EXERCISE_NAME_BICYCLE ((FIT_CORE_EXERCISE_NAME)49) +#define FIT_CORE_EXERCISE_NAME_BICEP_CURL_WITH_LEG_EXTENSION ((FIT_CORE_EXERCISE_NAME)50) +#define FIT_CORE_EXERCISE_NAME_CAT_COW ((FIT_CORE_EXERCISE_NAME)51) +#define FIT_CORE_EXERCISE_NAME_CORKSCREW ((FIT_CORE_EXERCISE_NAME)52) +#define FIT_CORE_EXERCISE_NAME_CRISS_CROSS ((FIT_CORE_EXERCISE_NAME)53) +#define FIT_CORE_EXERCISE_NAME_CRISS_CROSS_WITH_BALL ((FIT_CORE_EXERCISE_NAME)54) // Deprecated do not use +#define FIT_CORE_EXERCISE_NAME_DOUBLE_LEG_STRETCH ((FIT_CORE_EXERCISE_NAME)55) +#define FIT_CORE_EXERCISE_NAME_KNEE_FOLDS ((FIT_CORE_EXERCISE_NAME)56) +#define FIT_CORE_EXERCISE_NAME_LOWER_LIFT ((FIT_CORE_EXERCISE_NAME)57) +#define FIT_CORE_EXERCISE_NAME_NECK_PULL ((FIT_CORE_EXERCISE_NAME)58) +#define FIT_CORE_EXERCISE_NAME_PELVIC_CLOCKS ((FIT_CORE_EXERCISE_NAME)59) +#define FIT_CORE_EXERCISE_NAME_ROLL_OVER ((FIT_CORE_EXERCISE_NAME)60) +#define FIT_CORE_EXERCISE_NAME_ROLL_UP ((FIT_CORE_EXERCISE_NAME)61) +#define FIT_CORE_EXERCISE_NAME_ROLLING ((FIT_CORE_EXERCISE_NAME)62) +#define FIT_CORE_EXERCISE_NAME_ROWING_1 ((FIT_CORE_EXERCISE_NAME)63) +#define FIT_CORE_EXERCISE_NAME_ROWING_2 ((FIT_CORE_EXERCISE_NAME)64) +#define FIT_CORE_EXERCISE_NAME_SCISSORS ((FIT_CORE_EXERCISE_NAME)65) +#define FIT_CORE_EXERCISE_NAME_SINGLE_LEG_CIRCLES ((FIT_CORE_EXERCISE_NAME)66) +#define FIT_CORE_EXERCISE_NAME_SINGLE_LEG_STRETCH ((FIT_CORE_EXERCISE_NAME)67) +#define FIT_CORE_EXERCISE_NAME_SNAKE_TWIST_1_AND_2 ((FIT_CORE_EXERCISE_NAME)68) // Deprecated do not use +#define FIT_CORE_EXERCISE_NAME_SWAN ((FIT_CORE_EXERCISE_NAME)69) +#define FIT_CORE_EXERCISE_NAME_SWIMMING ((FIT_CORE_EXERCISE_NAME)70) +#define FIT_CORE_EXERCISE_NAME_TEASER ((FIT_CORE_EXERCISE_NAME)71) +#define FIT_CORE_EXERCISE_NAME_THE_HUNDRED ((FIT_CORE_EXERCISE_NAME)72) +#define FIT_CORE_EXERCISE_NAME_BICEP_CURL_WITH_LEG_EXTENSION_WITH_WEIGHTS ((FIT_CORE_EXERCISE_NAME)73) +#define FIT_CORE_EXERCISE_NAME_HANGING_L_SIT ((FIT_CORE_EXERCISE_NAME)75) +#define FIT_CORE_EXERCISE_NAME_LOWER_LIFT_WITH_WEIGHTS ((FIT_CORE_EXERCISE_NAME)77) +#define FIT_CORE_EXERCISE_NAME_RING_L_SIT ((FIT_CORE_EXERCISE_NAME)79) +#define FIT_CORE_EXERCISE_NAME_ROWING_1_WITH_WEIGHTS ((FIT_CORE_EXERCISE_NAME)80) +#define FIT_CORE_EXERCISE_NAME_ROWING_2_WITH_WEIGHTS ((FIT_CORE_EXERCISE_NAME)81) +#define FIT_CORE_EXERCISE_NAME_SCISSORS_WITH_WEIGHTS ((FIT_CORE_EXERCISE_NAME)82) +#define FIT_CORE_EXERCISE_NAME_SINGLE_LEG_STRETCH_WITH_WEIGHTS ((FIT_CORE_EXERCISE_NAME)83) +#define FIT_CORE_EXERCISE_NAME_TOES_TO_ELBOWS ((FIT_CORE_EXERCISE_NAME)84) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_CRISS_CROSS ((FIT_CORE_EXERCISE_NAME)85) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_DOUBLE_LEG_STRETCH ((FIT_CORE_EXERCISE_NAME)86) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_THE_HUNDRED ((FIT_CORE_EXERCISE_NAME)87) +#define FIT_CORE_EXERCISE_NAME_L_SIT ((FIT_CORE_EXERCISE_NAME)88) +#define FIT_CORE_EXERCISE_NAME_TURKISH_GET_UP ((FIT_CORE_EXERCISE_NAME)89) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_RING_L_SIT ((FIT_CORE_EXERCISE_NAME)90) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_HANGING_L_SIT ((FIT_CORE_EXERCISE_NAME)91) +#define FIT_CORE_EXERCISE_NAME_WEIGHTED_L_SIT ((FIT_CORE_EXERCISE_NAME)92) +#define FIT_CORE_EXERCISE_NAME_SIDE_BEND_LOW_WHEELCHAIR ((FIT_CORE_EXERCISE_NAME)93) +#define FIT_CORE_EXERCISE_NAME_SIDE_BEND_MID_WHEELCHAIR ((FIT_CORE_EXERCISE_NAME)94) +#define FIT_CORE_EXERCISE_NAME_SIDE_BEND_HIGH_WHEELCHAIR ((FIT_CORE_EXERCISE_NAME)95) +#define FIT_CORE_EXERCISE_NAME_SEATED_SIDE_BEND ((FIT_CORE_EXERCISE_NAME)96) +#define FIT_CORE_EXERCISE_NAME_COUNT 94 + +typedef FIT_UINT16 FIT_CRUNCH_EXERCISE_NAME; +#define FIT_CRUNCH_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CRUNCH_EXERCISE_NAME_BICYCLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)0) +#define FIT_CRUNCH_EXERCISE_NAME_CABLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)1) +#define FIT_CRUNCH_EXERCISE_NAME_CIRCULAR_ARM_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)2) +#define FIT_CRUNCH_EXERCISE_NAME_CROSSED_ARMS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)3) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_CROSSED_ARMS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)4) +#define FIT_CRUNCH_EXERCISE_NAME_CROSS_LEG_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)5) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_CROSS_LEG_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)6) +#define FIT_CRUNCH_EXERCISE_NAME_CRUNCH_CHOP ((FIT_CRUNCH_EXERCISE_NAME)7) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_CRUNCH_CHOP ((FIT_CRUNCH_EXERCISE_NAME)8) +#define FIT_CRUNCH_EXERCISE_NAME_DOUBLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)9) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_DOUBLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)10) +#define FIT_CRUNCH_EXERCISE_NAME_ELBOW_TO_KNEE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)11) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_ELBOW_TO_KNEE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)12) +#define FIT_CRUNCH_EXERCISE_NAME_FLUTTER_KICKS ((FIT_CRUNCH_EXERCISE_NAME)13) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_FLUTTER_KICKS ((FIT_CRUNCH_EXERCISE_NAME)14) +#define FIT_CRUNCH_EXERCISE_NAME_FOAM_ROLLER_REVERSE_CRUNCH_ON_BENCH ((FIT_CRUNCH_EXERCISE_NAME)15) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_FOAM_ROLLER_REVERSE_CRUNCH_ON_BENCH ((FIT_CRUNCH_EXERCISE_NAME)16) +#define FIT_CRUNCH_EXERCISE_NAME_FOAM_ROLLER_REVERSE_CRUNCH_WITH_DUMBBELL ((FIT_CRUNCH_EXERCISE_NAME)17) +#define FIT_CRUNCH_EXERCISE_NAME_FOAM_ROLLER_REVERSE_CRUNCH_WITH_MEDICINE_BALL ((FIT_CRUNCH_EXERCISE_NAME)18) +#define FIT_CRUNCH_EXERCISE_NAME_FROG_PRESS ((FIT_CRUNCH_EXERCISE_NAME)19) +#define FIT_CRUNCH_EXERCISE_NAME_HANGING_KNEE_RAISE_OBLIQUE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)20) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_HANGING_KNEE_RAISE_OBLIQUE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)21) +#define FIT_CRUNCH_EXERCISE_NAME_HIP_CROSSOVER ((FIT_CRUNCH_EXERCISE_NAME)22) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_HIP_CROSSOVER ((FIT_CRUNCH_EXERCISE_NAME)23) +#define FIT_CRUNCH_EXERCISE_NAME_HOLLOW_ROCK ((FIT_CRUNCH_EXERCISE_NAME)24) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_HOLLOW_ROCK ((FIT_CRUNCH_EXERCISE_NAME)25) +#define FIT_CRUNCH_EXERCISE_NAME_INCLINE_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)26) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_INCLINE_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)27) +#define FIT_CRUNCH_EXERCISE_NAME_KNEELING_CABLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)28) +#define FIT_CRUNCH_EXERCISE_NAME_KNEELING_CROSS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)29) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_KNEELING_CROSS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)30) +#define FIT_CRUNCH_EXERCISE_NAME_KNEELING_OBLIQUE_CABLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)31) +#define FIT_CRUNCH_EXERCISE_NAME_KNEES_TO_ELBOW ((FIT_CRUNCH_EXERCISE_NAME)32) +#define FIT_CRUNCH_EXERCISE_NAME_LEG_EXTENSIONS ((FIT_CRUNCH_EXERCISE_NAME)33) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_LEG_EXTENSIONS ((FIT_CRUNCH_EXERCISE_NAME)34) +#define FIT_CRUNCH_EXERCISE_NAME_LEG_LEVERS ((FIT_CRUNCH_EXERCISE_NAME)35) +#define FIT_CRUNCH_EXERCISE_NAME_MCGILL_CURL_UP ((FIT_CRUNCH_EXERCISE_NAME)36) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_MCGILL_CURL_UP ((FIT_CRUNCH_EXERCISE_NAME)37) +#define FIT_CRUNCH_EXERCISE_NAME_MODIFIED_PILATES_ROLL_UP_WITH_BALL ((FIT_CRUNCH_EXERCISE_NAME)38) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_MODIFIED_PILATES_ROLL_UP_WITH_BALL ((FIT_CRUNCH_EXERCISE_NAME)39) +#define FIT_CRUNCH_EXERCISE_NAME_PILATES_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)40) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_PILATES_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)41) +#define FIT_CRUNCH_EXERCISE_NAME_PILATES_ROLL_UP_WITH_BALL ((FIT_CRUNCH_EXERCISE_NAME)42) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_PILATES_ROLL_UP_WITH_BALL ((FIT_CRUNCH_EXERCISE_NAME)43) +#define FIT_CRUNCH_EXERCISE_NAME_RAISED_LEGS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)44) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_RAISED_LEGS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)45) +#define FIT_CRUNCH_EXERCISE_NAME_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)46) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)47) +#define FIT_CRUNCH_EXERCISE_NAME_REVERSE_CRUNCH_ON_A_BENCH ((FIT_CRUNCH_EXERCISE_NAME)48) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_REVERSE_CRUNCH_ON_A_BENCH ((FIT_CRUNCH_EXERCISE_NAME)49) +#define FIT_CRUNCH_EXERCISE_NAME_REVERSE_CURL_AND_LIFT ((FIT_CRUNCH_EXERCISE_NAME)50) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_REVERSE_CURL_AND_LIFT ((FIT_CRUNCH_EXERCISE_NAME)51) +#define FIT_CRUNCH_EXERCISE_NAME_ROTATIONAL_LIFT ((FIT_CRUNCH_EXERCISE_NAME)52) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_ROTATIONAL_LIFT ((FIT_CRUNCH_EXERCISE_NAME)53) +#define FIT_CRUNCH_EXERCISE_NAME_SEATED_ALTERNATING_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)54) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SEATED_ALTERNATING_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)55) +#define FIT_CRUNCH_EXERCISE_NAME_SEATED_LEG_U ((FIT_CRUNCH_EXERCISE_NAME)56) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SEATED_LEG_U ((FIT_CRUNCH_EXERCISE_NAME)57) +#define FIT_CRUNCH_EXERCISE_NAME_SIDE_TO_SIDE_CRUNCH_AND_WEAVE ((FIT_CRUNCH_EXERCISE_NAME)58) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SIDE_TO_SIDE_CRUNCH_AND_WEAVE ((FIT_CRUNCH_EXERCISE_NAME)59) +#define FIT_CRUNCH_EXERCISE_NAME_SINGLE_LEG_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)60) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)61) +#define FIT_CRUNCH_EXERCISE_NAME_SKATER_CRUNCH_CROSS ((FIT_CRUNCH_EXERCISE_NAME)62) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SKATER_CRUNCH_CROSS ((FIT_CRUNCH_EXERCISE_NAME)63) +#define FIT_CRUNCH_EXERCISE_NAME_STANDING_CABLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)64) +#define FIT_CRUNCH_EXERCISE_NAME_STANDING_SIDE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)65) +#define FIT_CRUNCH_EXERCISE_NAME_STEP_CLIMB ((FIT_CRUNCH_EXERCISE_NAME)66) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_STEP_CLIMB ((FIT_CRUNCH_EXERCISE_NAME)67) +#define FIT_CRUNCH_EXERCISE_NAME_SWISS_BALL_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)68) +#define FIT_CRUNCH_EXERCISE_NAME_SWISS_BALL_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)69) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SWISS_BALL_REVERSE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)70) +#define FIT_CRUNCH_EXERCISE_NAME_SWISS_BALL_RUSSIAN_TWIST ((FIT_CRUNCH_EXERCISE_NAME)71) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SWISS_BALL_RUSSIAN_TWIST ((FIT_CRUNCH_EXERCISE_NAME)72) +#define FIT_CRUNCH_EXERCISE_NAME_SWISS_BALL_SIDE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)73) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SWISS_BALL_SIDE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)74) +#define FIT_CRUNCH_EXERCISE_NAME_THORACIC_CRUNCHES_ON_FOAM_ROLLER ((FIT_CRUNCH_EXERCISE_NAME)75) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_THORACIC_CRUNCHES_ON_FOAM_ROLLER ((FIT_CRUNCH_EXERCISE_NAME)76) +#define FIT_CRUNCH_EXERCISE_NAME_TRICEPS_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)77) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_BICYCLE_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)78) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)79) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_SWISS_BALL_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)80) +#define FIT_CRUNCH_EXERCISE_NAME_TOES_TO_BAR ((FIT_CRUNCH_EXERCISE_NAME)81) +#define FIT_CRUNCH_EXERCISE_NAME_WEIGHTED_TOES_TO_BAR ((FIT_CRUNCH_EXERCISE_NAME)82) +#define FIT_CRUNCH_EXERCISE_NAME_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)83) +#define FIT_CRUNCH_EXERCISE_NAME_STRAIGHT_LEG_CRUNCH_WITH_BALL ((FIT_CRUNCH_EXERCISE_NAME)84) +#define FIT_CRUNCH_EXERCISE_NAME_LEG_CLIMB_CRUNCH ((FIT_CRUNCH_EXERCISE_NAME)86) +#define FIT_CRUNCH_EXERCISE_NAME_COUNT 86 + +typedef FIT_UINT16 FIT_CURL_EXERCISE_NAME; +#define FIT_CURL_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_CURL_EXERCISE_NAME_ALTERNATING_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)0) +#define FIT_CURL_EXERCISE_NAME_ALTERNATING_DUMBBELL_BICEPS_CURL_ON_SWISS_BALL ((FIT_CURL_EXERCISE_NAME)1) +#define FIT_CURL_EXERCISE_NAME_ALTERNATING_INCLINE_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)2) +#define FIT_CURL_EXERCISE_NAME_BARBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)3) +#define FIT_CURL_EXERCISE_NAME_BARBELL_REVERSE_WRIST_CURL ((FIT_CURL_EXERCISE_NAME)4) +#define FIT_CURL_EXERCISE_NAME_BARBELL_WRIST_CURL ((FIT_CURL_EXERCISE_NAME)5) +#define FIT_CURL_EXERCISE_NAME_BEHIND_THE_BACK_BARBELL_REVERSE_WRIST_CURL ((FIT_CURL_EXERCISE_NAME)6) +#define FIT_CURL_EXERCISE_NAME_BEHIND_THE_BACK_ONE_ARM_CABLE_CURL ((FIT_CURL_EXERCISE_NAME)7) +#define FIT_CURL_EXERCISE_NAME_CABLE_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)8) +#define FIT_CURL_EXERCISE_NAME_CABLE_HAMMER_CURL ((FIT_CURL_EXERCISE_NAME)9) +#define FIT_CURL_EXERCISE_NAME_CHEATING_BARBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)10) +#define FIT_CURL_EXERCISE_NAME_CLOSE_GRIP_EZ_BAR_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)11) +#define FIT_CURL_EXERCISE_NAME_CROSS_BODY_DUMBBELL_HAMMER_CURL ((FIT_CURL_EXERCISE_NAME)12) +#define FIT_CURL_EXERCISE_NAME_DEAD_HANG_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)13) +#define FIT_CURL_EXERCISE_NAME_DECLINE_HAMMER_CURL ((FIT_CURL_EXERCISE_NAME)14) +#define FIT_CURL_EXERCISE_NAME_DUMBBELL_BICEPS_CURL_WITH_STATIC_HOLD ((FIT_CURL_EXERCISE_NAME)15) +#define FIT_CURL_EXERCISE_NAME_DUMBBELL_HAMMER_CURL ((FIT_CURL_EXERCISE_NAME)16) +#define FIT_CURL_EXERCISE_NAME_DUMBBELL_REVERSE_WRIST_CURL ((FIT_CURL_EXERCISE_NAME)17) +#define FIT_CURL_EXERCISE_NAME_DUMBBELL_WRIST_CURL ((FIT_CURL_EXERCISE_NAME)18) +#define FIT_CURL_EXERCISE_NAME_EZ_BAR_PREACHER_CURL ((FIT_CURL_EXERCISE_NAME)19) +#define FIT_CURL_EXERCISE_NAME_FORWARD_BEND_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)20) +#define FIT_CURL_EXERCISE_NAME_HAMMER_CURL_TO_PRESS ((FIT_CURL_EXERCISE_NAME)21) +#define FIT_CURL_EXERCISE_NAME_INCLINE_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)22) +#define FIT_CURL_EXERCISE_NAME_INCLINE_OFFSET_THUMB_DUMBBELL_CURL ((FIT_CURL_EXERCISE_NAME)23) +#define FIT_CURL_EXERCISE_NAME_KETTLEBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)24) +#define FIT_CURL_EXERCISE_NAME_LYING_CONCENTRATION_CABLE_CURL ((FIT_CURL_EXERCISE_NAME)25) +#define FIT_CURL_EXERCISE_NAME_ONE_ARM_PREACHER_CURL ((FIT_CURL_EXERCISE_NAME)26) +#define FIT_CURL_EXERCISE_NAME_PLATE_PINCH_CURL ((FIT_CURL_EXERCISE_NAME)27) +#define FIT_CURL_EXERCISE_NAME_PREACHER_CURL_WITH_CABLE ((FIT_CURL_EXERCISE_NAME)28) +#define FIT_CURL_EXERCISE_NAME_REVERSE_EZ_BAR_CURL ((FIT_CURL_EXERCISE_NAME)29) +#define FIT_CURL_EXERCISE_NAME_REVERSE_GRIP_WRIST_CURL ((FIT_CURL_EXERCISE_NAME)30) +#define FIT_CURL_EXERCISE_NAME_REVERSE_GRIP_BARBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)31) +#define FIT_CURL_EXERCISE_NAME_SEATED_ALTERNATING_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)32) +#define FIT_CURL_EXERCISE_NAME_SEATED_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)33) +#define FIT_CURL_EXERCISE_NAME_SEATED_REVERSE_DUMBBELL_CURL ((FIT_CURL_EXERCISE_NAME)34) +#define FIT_CURL_EXERCISE_NAME_SPLIT_STANCE_OFFSET_PINKY_DUMBBELL_CURL ((FIT_CURL_EXERCISE_NAME)35) +#define FIT_CURL_EXERCISE_NAME_STANDING_ALTERNATING_DUMBBELL_CURLS ((FIT_CURL_EXERCISE_NAME)36) +#define FIT_CURL_EXERCISE_NAME_STANDING_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)37) +#define FIT_CURL_EXERCISE_NAME_STANDING_EZ_BAR_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)38) +#define FIT_CURL_EXERCISE_NAME_STATIC_CURL ((FIT_CURL_EXERCISE_NAME)39) +#define FIT_CURL_EXERCISE_NAME_SWISS_BALL_DUMBBELL_OVERHEAD_TRICEPS_EXTENSION ((FIT_CURL_EXERCISE_NAME)40) +#define FIT_CURL_EXERCISE_NAME_SWISS_BALL_EZ_BAR_PREACHER_CURL ((FIT_CURL_EXERCISE_NAME)41) +#define FIT_CURL_EXERCISE_NAME_TWISTING_STANDING_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)42) +#define FIT_CURL_EXERCISE_NAME_WIDE_GRIP_EZ_BAR_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)43) +#define FIT_CURL_EXERCISE_NAME_ONE_ARM_CONCENTRATION_CURL ((FIT_CURL_EXERCISE_NAME)44) +#define FIT_CURL_EXERCISE_NAME_STANDING_ZOTTMAN_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)45) +#define FIT_CURL_EXERCISE_NAME_DUMBBELL_BICEPS_CURL ((FIT_CURL_EXERCISE_NAME)46) +#define FIT_CURL_EXERCISE_NAME_DRAG_CURL_WHEELCHAIR ((FIT_CURL_EXERCISE_NAME)47) +#define FIT_CURL_EXERCISE_NAME_DUMBBELL_BICEPS_CURL_WHEELCHAIR ((FIT_CURL_EXERCISE_NAME)48) +#define FIT_CURL_EXERCISE_NAME_BOTTLE_CURL ((FIT_CURL_EXERCISE_NAME)49) +#define FIT_CURL_EXERCISE_NAME_SEATED_BOTTLE_CURL ((FIT_CURL_EXERCISE_NAME)50) +#define FIT_CURL_EXERCISE_NAME_COUNT 51 + +typedef FIT_UINT16 FIT_DEADLIFT_EXERCISE_NAME; +#define FIT_DEADLIFT_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_DEADLIFT_EXERCISE_NAME_BARBELL_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)0) +#define FIT_DEADLIFT_EXERCISE_NAME_BARBELL_STRAIGHT_LEG_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)1) +#define FIT_DEADLIFT_EXERCISE_NAME_DUMBBELL_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)2) +#define FIT_DEADLIFT_EXERCISE_NAME_DUMBBELL_SINGLE_LEG_DEADLIFT_TO_ROW ((FIT_DEADLIFT_EXERCISE_NAME)3) +#define FIT_DEADLIFT_EXERCISE_NAME_DUMBBELL_STRAIGHT_LEG_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)4) +#define FIT_DEADLIFT_EXERCISE_NAME_KETTLEBELL_FLOOR_TO_SHELF ((FIT_DEADLIFT_EXERCISE_NAME)5) +#define FIT_DEADLIFT_EXERCISE_NAME_ONE_ARM_ONE_LEG_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)6) +#define FIT_DEADLIFT_EXERCISE_NAME_RACK_PULL ((FIT_DEADLIFT_EXERCISE_NAME)7) +#define FIT_DEADLIFT_EXERCISE_NAME_ROTATIONAL_DUMBBELL_STRAIGHT_LEG_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)8) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_ARM_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)9) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_LEG_BARBELL_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)10) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_LEG_BARBELL_STRAIGHT_LEG_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)11) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_LEG_DEADLIFT_WITH_BARBELL ((FIT_DEADLIFT_EXERCISE_NAME)12) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_LEG_RDL_CIRCUIT ((FIT_DEADLIFT_EXERCISE_NAME)13) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_LEG_ROMANIAN_DEADLIFT_WITH_DUMBBELL ((FIT_DEADLIFT_EXERCISE_NAME)14) +#define FIT_DEADLIFT_EXERCISE_NAME_SUMO_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)15) +#define FIT_DEADLIFT_EXERCISE_NAME_SUMO_DEADLIFT_HIGH_PULL ((FIT_DEADLIFT_EXERCISE_NAME)16) +#define FIT_DEADLIFT_EXERCISE_NAME_TRAP_BAR_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)17) +#define FIT_DEADLIFT_EXERCISE_NAME_WIDE_GRIP_BARBELL_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)18) +#define FIT_DEADLIFT_EXERCISE_NAME_KETTLEBELL_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)20) +#define FIT_DEADLIFT_EXERCISE_NAME_KETTLEBELL_SUMO_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)21) +#define FIT_DEADLIFT_EXERCISE_NAME_ROMANIAN_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)23) +#define FIT_DEADLIFT_EXERCISE_NAME_SINGLE_LEG_ROMANIAN_DEADLIFT_CIRCUIT ((FIT_DEADLIFT_EXERCISE_NAME)24) +#define FIT_DEADLIFT_EXERCISE_NAME_STRAIGHT_LEG_DEADLIFT ((FIT_DEADLIFT_EXERCISE_NAME)25) +#define FIT_DEADLIFT_EXERCISE_NAME_COUNT 24 + +typedef FIT_UINT16 FIT_FLYE_EXERCISE_NAME; +#define FIT_FLYE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_FLYE_EXERCISE_NAME_CABLE_CROSSOVER ((FIT_FLYE_EXERCISE_NAME)0) +#define FIT_FLYE_EXERCISE_NAME_DECLINE_DUMBBELL_FLYE ((FIT_FLYE_EXERCISE_NAME)1) +#define FIT_FLYE_EXERCISE_NAME_DUMBBELL_FLYE ((FIT_FLYE_EXERCISE_NAME)2) +#define FIT_FLYE_EXERCISE_NAME_INCLINE_DUMBBELL_FLYE ((FIT_FLYE_EXERCISE_NAME)3) +#define FIT_FLYE_EXERCISE_NAME_KETTLEBELL_FLYE ((FIT_FLYE_EXERCISE_NAME)4) +#define FIT_FLYE_EXERCISE_NAME_KNEELING_REAR_FLYE ((FIT_FLYE_EXERCISE_NAME)5) +#define FIT_FLYE_EXERCISE_NAME_SINGLE_ARM_STANDING_CABLE_REVERSE_FLYE ((FIT_FLYE_EXERCISE_NAME)6) +#define FIT_FLYE_EXERCISE_NAME_SWISS_BALL_DUMBBELL_FLYE ((FIT_FLYE_EXERCISE_NAME)7) +#define FIT_FLYE_EXERCISE_NAME_ARM_ROTATIONS ((FIT_FLYE_EXERCISE_NAME)8) +#define FIT_FLYE_EXERCISE_NAME_HUG_A_TREE ((FIT_FLYE_EXERCISE_NAME)9) +#define FIT_FLYE_EXERCISE_NAME_FACE_DOWN_INCLINE_REVERSE_FLYE ((FIT_FLYE_EXERCISE_NAME)10) +#define FIT_FLYE_EXERCISE_NAME_INCLINE_REVERSE_FLYE ((FIT_FLYE_EXERCISE_NAME)11) +#define FIT_FLYE_EXERCISE_NAME_REAR_DELT_FLY_WHEELCHAIR ((FIT_FLYE_EXERCISE_NAME)12) +#define FIT_FLYE_EXERCISE_NAME_COUNT 13 + +typedef FIT_UINT16 FIT_HIP_RAISE_EXERCISE_NAME; +#define FIT_HIP_RAISE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_HIP_RAISE_EXERCISE_NAME_BARBELL_HIP_THRUST_ON_FLOOR ((FIT_HIP_RAISE_EXERCISE_NAME)0) +#define FIT_HIP_RAISE_EXERCISE_NAME_BARBELL_HIP_THRUST_WITH_BENCH ((FIT_HIP_RAISE_EXERCISE_NAME)1) +#define FIT_HIP_RAISE_EXERCISE_NAME_BENT_KNEE_SWISS_BALL_REVERSE_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)2) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_BENT_KNEE_SWISS_BALL_REVERSE_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)3) +#define FIT_HIP_RAISE_EXERCISE_NAME_BRIDGE_WITH_LEG_EXTENSION ((FIT_HIP_RAISE_EXERCISE_NAME)4) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_BRIDGE_WITH_LEG_EXTENSION ((FIT_HIP_RAISE_EXERCISE_NAME)5) +#define FIT_HIP_RAISE_EXERCISE_NAME_CLAM_BRIDGE ((FIT_HIP_RAISE_EXERCISE_NAME)6) +#define FIT_HIP_RAISE_EXERCISE_NAME_FRONT_KICK_TABLETOP ((FIT_HIP_RAISE_EXERCISE_NAME)7) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_FRONT_KICK_TABLETOP ((FIT_HIP_RAISE_EXERCISE_NAME)8) +#define FIT_HIP_RAISE_EXERCISE_NAME_HIP_EXTENSION_AND_CROSS ((FIT_HIP_RAISE_EXERCISE_NAME)9) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_HIP_EXTENSION_AND_CROSS ((FIT_HIP_RAISE_EXERCISE_NAME)10) +#define FIT_HIP_RAISE_EXERCISE_NAME_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)11) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)12) +#define FIT_HIP_RAISE_EXERCISE_NAME_HIP_RAISE_WITH_FEET_ON_SWISS_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)13) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_HIP_RAISE_WITH_FEET_ON_SWISS_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)14) +#define FIT_HIP_RAISE_EXERCISE_NAME_HIP_RAISE_WITH_HEAD_ON_BOSU_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)15) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_HIP_RAISE_WITH_HEAD_ON_BOSU_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)16) +#define FIT_HIP_RAISE_EXERCISE_NAME_HIP_RAISE_WITH_HEAD_ON_SWISS_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)17) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_HIP_RAISE_WITH_HEAD_ON_SWISS_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)18) +#define FIT_HIP_RAISE_EXERCISE_NAME_HIP_RAISE_WITH_KNEE_SQUEEZE ((FIT_HIP_RAISE_EXERCISE_NAME)19) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_HIP_RAISE_WITH_KNEE_SQUEEZE ((FIT_HIP_RAISE_EXERCISE_NAME)20) +#define FIT_HIP_RAISE_EXERCISE_NAME_INCLINE_REAR_LEG_EXTENSION ((FIT_HIP_RAISE_EXERCISE_NAME)21) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_INCLINE_REAR_LEG_EXTENSION ((FIT_HIP_RAISE_EXERCISE_NAME)22) +#define FIT_HIP_RAISE_EXERCISE_NAME_KETTLEBELL_SWING ((FIT_HIP_RAISE_EXERCISE_NAME)23) +#define FIT_HIP_RAISE_EXERCISE_NAME_MARCHING_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)24) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_MARCHING_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)25) +#define FIT_HIP_RAISE_EXERCISE_NAME_MARCHING_HIP_RAISE_WITH_FEET_ON_A_SWISS_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)26) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_MARCHING_HIP_RAISE_WITH_FEET_ON_A_SWISS_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)27) +#define FIT_HIP_RAISE_EXERCISE_NAME_REVERSE_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)28) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_REVERSE_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)29) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)30) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_HIP_RAISE ((FIT_HIP_RAISE_EXERCISE_NAME)31) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_BENCH ((FIT_HIP_RAISE_EXERCISE_NAME)32) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_BENCH ((FIT_HIP_RAISE_EXERCISE_NAME)33) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_BOSU_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)34) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_BOSU_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)35) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_FOAM_ROLLER ((FIT_HIP_RAISE_EXERCISE_NAME)36) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_FOAM_ROLLER ((FIT_HIP_RAISE_EXERCISE_NAME)37) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_MEDICINE_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)38) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_HIP_RAISE_WITH_FOOT_ON_MEDICINE_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)39) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_HIP_RAISE_WITH_HEAD_ON_BOSU_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)40) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_HIP_RAISE_WITH_HEAD_ON_BOSU_BALL ((FIT_HIP_RAISE_EXERCISE_NAME)41) +#define FIT_HIP_RAISE_EXERCISE_NAME_WEIGHTED_CLAM_BRIDGE ((FIT_HIP_RAISE_EXERCISE_NAME)42) +#define FIT_HIP_RAISE_EXERCISE_NAME_SINGLE_LEG_SWISS_BALL_HIP_RAISE_AND_LEG_CURL ((FIT_HIP_RAISE_EXERCISE_NAME)43) +#define FIT_HIP_RAISE_EXERCISE_NAME_CLAMS ((FIT_HIP_RAISE_EXERCISE_NAME)44) +#define FIT_HIP_RAISE_EXERCISE_NAME_INNER_THIGH_CIRCLES ((FIT_HIP_RAISE_EXERCISE_NAME)45) // Deprecated do not use +#define FIT_HIP_RAISE_EXERCISE_NAME_INNER_THIGH_SIDE_LIFT ((FIT_HIP_RAISE_EXERCISE_NAME)46) // Deprecated do not use +#define FIT_HIP_RAISE_EXERCISE_NAME_LEG_CIRCLES ((FIT_HIP_RAISE_EXERCISE_NAME)47) +#define FIT_HIP_RAISE_EXERCISE_NAME_LEG_LIFT ((FIT_HIP_RAISE_EXERCISE_NAME)48) +#define FIT_HIP_RAISE_EXERCISE_NAME_LEG_LIFT_IN_EXTERNAL_ROTATION ((FIT_HIP_RAISE_EXERCISE_NAME)49) +#define FIT_HIP_RAISE_EXERCISE_NAME_COUNT 50 + +typedef FIT_UINT16 FIT_HIP_STABILITY_EXERCISE_NAME; +#define FIT_HIP_STABILITY_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_HIP_STABILITY_EXERCISE_NAME_BAND_SIDE_LYING_LEG_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)0) +#define FIT_HIP_STABILITY_EXERCISE_NAME_DEAD_BUG ((FIT_HIP_STABILITY_EXERCISE_NAME)1) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_DEAD_BUG ((FIT_HIP_STABILITY_EXERCISE_NAME)2) +#define FIT_HIP_STABILITY_EXERCISE_NAME_EXTERNAL_HIP_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)3) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_EXTERNAL_HIP_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)4) +#define FIT_HIP_STABILITY_EXERCISE_NAME_FIRE_HYDRANT_KICKS ((FIT_HIP_STABILITY_EXERCISE_NAME)5) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_FIRE_HYDRANT_KICKS ((FIT_HIP_STABILITY_EXERCISE_NAME)6) +#define FIT_HIP_STABILITY_EXERCISE_NAME_HIP_CIRCLES ((FIT_HIP_STABILITY_EXERCISE_NAME)7) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_HIP_CIRCLES ((FIT_HIP_STABILITY_EXERCISE_NAME)8) +#define FIT_HIP_STABILITY_EXERCISE_NAME_INNER_THIGH_LIFT ((FIT_HIP_STABILITY_EXERCISE_NAME)9) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_INNER_THIGH_LIFT ((FIT_HIP_STABILITY_EXERCISE_NAME)10) +#define FIT_HIP_STABILITY_EXERCISE_NAME_LATERAL_WALKS_WITH_BAND_AT_ANKLES ((FIT_HIP_STABILITY_EXERCISE_NAME)11) +#define FIT_HIP_STABILITY_EXERCISE_NAME_PRETZEL_SIDE_KICK ((FIT_HIP_STABILITY_EXERCISE_NAME)12) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_PRETZEL_SIDE_KICK ((FIT_HIP_STABILITY_EXERCISE_NAME)13) +#define FIT_HIP_STABILITY_EXERCISE_NAME_PRONE_HIP_INTERNAL_ROTATION ((FIT_HIP_STABILITY_EXERCISE_NAME)14) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_PRONE_HIP_INTERNAL_ROTATION ((FIT_HIP_STABILITY_EXERCISE_NAME)15) +#define FIT_HIP_STABILITY_EXERCISE_NAME_QUADRUPED ((FIT_HIP_STABILITY_EXERCISE_NAME)16) +#define FIT_HIP_STABILITY_EXERCISE_NAME_QUADRUPED_HIP_EXTENSION ((FIT_HIP_STABILITY_EXERCISE_NAME)17) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_QUADRUPED_HIP_EXTENSION ((FIT_HIP_STABILITY_EXERCISE_NAME)18) +#define FIT_HIP_STABILITY_EXERCISE_NAME_QUADRUPED_WITH_LEG_LIFT ((FIT_HIP_STABILITY_EXERCISE_NAME)19) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_QUADRUPED_WITH_LEG_LIFT ((FIT_HIP_STABILITY_EXERCISE_NAME)20) +#define FIT_HIP_STABILITY_EXERCISE_NAME_SIDE_LYING_LEG_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)21) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_SIDE_LYING_LEG_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)22) +#define FIT_HIP_STABILITY_EXERCISE_NAME_SLIDING_HIP_ADDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)23) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_SLIDING_HIP_ADDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)24) +#define FIT_HIP_STABILITY_EXERCISE_NAME_STANDING_ADDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)25) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_STANDING_ADDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)26) +#define FIT_HIP_STABILITY_EXERCISE_NAME_STANDING_CABLE_HIP_ABDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)27) +#define FIT_HIP_STABILITY_EXERCISE_NAME_STANDING_HIP_ABDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)28) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_STANDING_HIP_ABDUCTION ((FIT_HIP_STABILITY_EXERCISE_NAME)29) +#define FIT_HIP_STABILITY_EXERCISE_NAME_STANDING_REAR_LEG_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)30) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_STANDING_REAR_LEG_RAISE ((FIT_HIP_STABILITY_EXERCISE_NAME)31) +#define FIT_HIP_STABILITY_EXERCISE_NAME_SUPINE_HIP_INTERNAL_ROTATION ((FIT_HIP_STABILITY_EXERCISE_NAME)32) +#define FIT_HIP_STABILITY_EXERCISE_NAME_WEIGHTED_SUPINE_HIP_INTERNAL_ROTATION ((FIT_HIP_STABILITY_EXERCISE_NAME)33) +#define FIT_HIP_STABILITY_EXERCISE_NAME_LYING_ABDUCTION_STRETCH ((FIT_HIP_STABILITY_EXERCISE_NAME)34) +#define FIT_HIP_STABILITY_EXERCISE_NAME_COUNT 35 + +typedef FIT_UINT16 FIT_HIP_SWING_EXERCISE_NAME; +#define FIT_HIP_SWING_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_HIP_SWING_EXERCISE_NAME_SINGLE_ARM_KETTLEBELL_SWING ((FIT_HIP_SWING_EXERCISE_NAME)0) +#define FIT_HIP_SWING_EXERCISE_NAME_SINGLE_ARM_DUMBBELL_SWING ((FIT_HIP_SWING_EXERCISE_NAME)1) +#define FIT_HIP_SWING_EXERCISE_NAME_STEP_OUT_SWING ((FIT_HIP_SWING_EXERCISE_NAME)2) +#define FIT_HIP_SWING_EXERCISE_NAME_ONE_ARM_SWING ((FIT_HIP_SWING_EXERCISE_NAME)3) +#define FIT_HIP_SWING_EXERCISE_NAME_COUNT 4 + +typedef FIT_UINT16 FIT_HYPEREXTENSION_EXERCISE_NAME; +#define FIT_HYPEREXTENSION_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_HYPEREXTENSION_EXERCISE_NAME_BACK_EXTENSION_WITH_OPPOSITE_ARM_AND_LEG_REACH ((FIT_HYPEREXTENSION_EXERCISE_NAME)0) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_BACK_EXTENSION_WITH_OPPOSITE_ARM_AND_LEG_REACH ((FIT_HYPEREXTENSION_EXERCISE_NAME)1) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_BASE_ROTATIONS ((FIT_HYPEREXTENSION_EXERCISE_NAME)2) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_BASE_ROTATIONS ((FIT_HYPEREXTENSION_EXERCISE_NAME)3) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_BENT_KNEE_REVERSE_HYPEREXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)4) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_BENT_KNEE_REVERSE_HYPEREXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)5) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_HOLLOW_HOLD_AND_ROLL ((FIT_HYPEREXTENSION_EXERCISE_NAME)6) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_HOLLOW_HOLD_AND_ROLL ((FIT_HYPEREXTENSION_EXERCISE_NAME)7) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_KICKS ((FIT_HYPEREXTENSION_EXERCISE_NAME)8) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_KICKS ((FIT_HYPEREXTENSION_EXERCISE_NAME)9) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_KNEE_RAISES ((FIT_HYPEREXTENSION_EXERCISE_NAME)10) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_KNEE_RAISES ((FIT_HYPEREXTENSION_EXERCISE_NAME)11) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_KNEELING_SUPERMAN ((FIT_HYPEREXTENSION_EXERCISE_NAME)12) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_KNEELING_SUPERMAN ((FIT_HYPEREXTENSION_EXERCISE_NAME)13) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_LAT_PULL_DOWN_WITH_ROW ((FIT_HYPEREXTENSION_EXERCISE_NAME)14) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_MEDICINE_BALL_DEADLIFT_TO_REACH ((FIT_HYPEREXTENSION_EXERCISE_NAME)15) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_ONE_ARM_ONE_LEG_ROW ((FIT_HYPEREXTENSION_EXERCISE_NAME)16) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_ONE_ARM_ROW_WITH_BAND ((FIT_HYPEREXTENSION_EXERCISE_NAME)17) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_OVERHEAD_LUNGE_WITH_MEDICINE_BALL ((FIT_HYPEREXTENSION_EXERCISE_NAME)18) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_PLANK_KNEE_TUCKS ((FIT_HYPEREXTENSION_EXERCISE_NAME)19) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_PLANK_KNEE_TUCKS ((FIT_HYPEREXTENSION_EXERCISE_NAME)20) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SIDE_STEP ((FIT_HYPEREXTENSION_EXERCISE_NAME)21) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SIDE_STEP ((FIT_HYPEREXTENSION_EXERCISE_NAME)22) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SINGLE_LEG_BACK_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)23) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_BACK_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)24) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SPINE_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)25) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SPINE_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)26) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_STATIC_BACK_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)27) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_STATIC_BACK_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)28) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SUPERMAN_FROM_FLOOR ((FIT_HYPEREXTENSION_EXERCISE_NAME)29) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SUPERMAN_FROM_FLOOR ((FIT_HYPEREXTENSION_EXERCISE_NAME)30) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SWISS_BALL_BACK_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)31) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SWISS_BALL_BACK_EXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)32) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SWISS_BALL_HYPEREXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)33) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SWISS_BALL_HYPEREXTENSION ((FIT_HYPEREXTENSION_EXERCISE_NAME)34) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SWISS_BALL_OPPOSITE_ARM_AND_LEG_LIFT ((FIT_HYPEREXTENSION_EXERCISE_NAME)35) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_WEIGHTED_SWISS_BALL_OPPOSITE_ARM_AND_LEG_LIFT ((FIT_HYPEREXTENSION_EXERCISE_NAME)36) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SUPERMAN_ON_SWISS_BALL ((FIT_HYPEREXTENSION_EXERCISE_NAME)37) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_COBRA ((FIT_HYPEREXTENSION_EXERCISE_NAME)38) +#define FIT_HYPEREXTENSION_EXERCISE_NAME_SUPINE_FLOOR_BARRE ((FIT_HYPEREXTENSION_EXERCISE_NAME)39) // Deprecated do not use +#define FIT_HYPEREXTENSION_EXERCISE_NAME_COUNT 40 + +typedef FIT_UINT16 FIT_LATERAL_RAISE_EXERCISE_NAME; +#define FIT_LATERAL_RAISE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_LATERAL_RAISE_EXERCISE_NAME_45_DEGREE_CABLE_EXTERNAL_ROTATION ((FIT_LATERAL_RAISE_EXERCISE_NAME)0) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_ALTERNATING_LATERAL_RAISE_WITH_STATIC_HOLD ((FIT_LATERAL_RAISE_EXERCISE_NAME)1) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_BAR_MUSCLE_UP ((FIT_LATERAL_RAISE_EXERCISE_NAME)2) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_BENT_OVER_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)3) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_CABLE_DIAGONAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)4) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_CABLE_FRONT_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)5) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_CALORIE_ROW ((FIT_LATERAL_RAISE_EXERCISE_NAME)6) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_COMBO_SHOULDER_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)7) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_DUMBBELL_DIAGONAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)8) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_DUMBBELL_V_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)9) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_FRONT_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)10) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_LEANING_DUMBBELL_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)11) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_LYING_DUMBBELL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)12) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_MUSCLE_UP ((FIT_LATERAL_RAISE_EXERCISE_NAME)13) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_ONE_ARM_CABLE_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)14) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_OVERHAND_GRIP_REAR_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)15) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_PLATE_RAISES ((FIT_LATERAL_RAISE_EXERCISE_NAME)16) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_RING_DIP ((FIT_LATERAL_RAISE_EXERCISE_NAME)17) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_WEIGHTED_RING_DIP ((FIT_LATERAL_RAISE_EXERCISE_NAME)18) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_RING_MUSCLE_UP ((FIT_LATERAL_RAISE_EXERCISE_NAME)19) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_WEIGHTED_RING_MUSCLE_UP ((FIT_LATERAL_RAISE_EXERCISE_NAME)20) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_ROPE_CLIMB ((FIT_LATERAL_RAISE_EXERCISE_NAME)21) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_WEIGHTED_ROPE_CLIMB ((FIT_LATERAL_RAISE_EXERCISE_NAME)22) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_SCAPTION ((FIT_LATERAL_RAISE_EXERCISE_NAME)23) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_SEATED_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)24) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_SEATED_REAR_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)25) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_SIDE_LYING_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)26) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_STANDING_LIFT ((FIT_LATERAL_RAISE_EXERCISE_NAME)27) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_SUSPENDED_ROW ((FIT_LATERAL_RAISE_EXERCISE_NAME)28) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_UNDERHAND_GRIP_REAR_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)29) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_WALL_SLIDE ((FIT_LATERAL_RAISE_EXERCISE_NAME)30) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_WEIGHTED_WALL_SLIDE ((FIT_LATERAL_RAISE_EXERCISE_NAME)31) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_ARM_CIRCLES ((FIT_LATERAL_RAISE_EXERCISE_NAME)32) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_SHAVING_THE_HEAD ((FIT_LATERAL_RAISE_EXERCISE_NAME)33) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_DUMBBELL_LATERAL_RAISE ((FIT_LATERAL_RAISE_EXERCISE_NAME)34) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_RING_DIP_KIPPING ((FIT_LATERAL_RAISE_EXERCISE_NAME)36) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_WALL_WALK ((FIT_LATERAL_RAISE_EXERCISE_NAME)37) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_DUMBBELL_FRONT_RAISE_WHEELCHAIR ((FIT_LATERAL_RAISE_EXERCISE_NAME)38) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_DUMBBELL_LATERAL_RAISE_WHEELCHAIR ((FIT_LATERAL_RAISE_EXERCISE_NAME)39) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_POLE_DOUBLE_ARM_OVERHEAD_AND_FORWARD_WHEELCHAIR ((FIT_LATERAL_RAISE_EXERCISE_NAME)40) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_POLE_STRAIGHT_ARM_OVERHEAD_WHEELCHAIR ((FIT_LATERAL_RAISE_EXERCISE_NAME)41) +#define FIT_LATERAL_RAISE_EXERCISE_NAME_COUNT 41 + +typedef FIT_UINT16 FIT_LEG_CURL_EXERCISE_NAME; +#define FIT_LEG_CURL_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_LEG_CURL_EXERCISE_NAME_LEG_CURL ((FIT_LEG_CURL_EXERCISE_NAME)0) +#define FIT_LEG_CURL_EXERCISE_NAME_WEIGHTED_LEG_CURL ((FIT_LEG_CURL_EXERCISE_NAME)1) +#define FIT_LEG_CURL_EXERCISE_NAME_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)2) +#define FIT_LEG_CURL_EXERCISE_NAME_SEATED_BARBELL_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)3) +#define FIT_LEG_CURL_EXERCISE_NAME_SINGLE_LEG_BARBELL_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)4) +#define FIT_LEG_CURL_EXERCISE_NAME_SINGLE_LEG_SLIDING_LEG_CURL ((FIT_LEG_CURL_EXERCISE_NAME)5) +#define FIT_LEG_CURL_EXERCISE_NAME_SLIDING_LEG_CURL ((FIT_LEG_CURL_EXERCISE_NAME)6) +#define FIT_LEG_CURL_EXERCISE_NAME_SPLIT_BARBELL_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)7) +#define FIT_LEG_CURL_EXERCISE_NAME_SPLIT_STANCE_EXTENSION ((FIT_LEG_CURL_EXERCISE_NAME)8) +#define FIT_LEG_CURL_EXERCISE_NAME_STAGGERED_STANCE_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)9) +#define FIT_LEG_CURL_EXERCISE_NAME_SWISS_BALL_HIP_RAISE_AND_LEG_CURL ((FIT_LEG_CURL_EXERCISE_NAME)10) +#define FIT_LEG_CURL_EXERCISE_NAME_ZERCHER_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)11) +#define FIT_LEG_CURL_EXERCISE_NAME_BAND_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)12) +#define FIT_LEG_CURL_EXERCISE_NAME_BAR_GOOD_MORNING ((FIT_LEG_CURL_EXERCISE_NAME)13) +#define FIT_LEG_CURL_EXERCISE_NAME_COUNT 14 + +typedef FIT_UINT16 FIT_LEG_RAISE_EXERCISE_NAME; +#define FIT_LEG_RAISE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_LEG_RAISE_EXERCISE_NAME_HANGING_KNEE_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)0) +#define FIT_LEG_RAISE_EXERCISE_NAME_HANGING_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)1) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_HANGING_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)2) +#define FIT_LEG_RAISE_EXERCISE_NAME_HANGING_SINGLE_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)3) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_HANGING_SINGLE_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)4) +#define FIT_LEG_RAISE_EXERCISE_NAME_KETTLEBELL_LEG_RAISES ((FIT_LEG_RAISE_EXERCISE_NAME)5) +#define FIT_LEG_RAISE_EXERCISE_NAME_LEG_LOWERING_DRILL ((FIT_LEG_RAISE_EXERCISE_NAME)6) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_LEG_LOWERING_DRILL ((FIT_LEG_RAISE_EXERCISE_NAME)7) +#define FIT_LEG_RAISE_EXERCISE_NAME_LYING_STRAIGHT_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)8) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_LYING_STRAIGHT_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)9) +#define FIT_LEG_RAISE_EXERCISE_NAME_MEDICINE_BALL_LEG_DROPS ((FIT_LEG_RAISE_EXERCISE_NAME)10) +#define FIT_LEG_RAISE_EXERCISE_NAME_QUADRUPED_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)11) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_QUADRUPED_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)12) +#define FIT_LEG_RAISE_EXERCISE_NAME_REVERSE_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)13) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_REVERSE_LEG_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)14) +#define FIT_LEG_RAISE_EXERCISE_NAME_REVERSE_LEG_RAISE_ON_SWISS_BALL ((FIT_LEG_RAISE_EXERCISE_NAME)15) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_REVERSE_LEG_RAISE_ON_SWISS_BALL ((FIT_LEG_RAISE_EXERCISE_NAME)16) +#define FIT_LEG_RAISE_EXERCISE_NAME_SINGLE_LEG_LOWERING_DRILL ((FIT_LEG_RAISE_EXERCISE_NAME)17) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_LOWERING_DRILL ((FIT_LEG_RAISE_EXERCISE_NAME)18) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_HANGING_KNEE_RAISE ((FIT_LEG_RAISE_EXERCISE_NAME)19) +#define FIT_LEG_RAISE_EXERCISE_NAME_LATERAL_STEPOVER ((FIT_LEG_RAISE_EXERCISE_NAME)20) +#define FIT_LEG_RAISE_EXERCISE_NAME_WEIGHTED_LATERAL_STEPOVER ((FIT_LEG_RAISE_EXERCISE_NAME)21) +#define FIT_LEG_RAISE_EXERCISE_NAME_COUNT 22 + +typedef FIT_UINT16 FIT_LUNGE_EXERCISE_NAME; +#define FIT_LUNGE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_LUNGE_EXERCISE_NAME_OVERHEAD_LUNGE ((FIT_LUNGE_EXERCISE_NAME)0) +#define FIT_LUNGE_EXERCISE_NAME_LUNGE_MATRIX ((FIT_LUNGE_EXERCISE_NAME)1) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_LUNGE_MATRIX ((FIT_LUNGE_EXERCISE_NAME)2) +#define FIT_LUNGE_EXERCISE_NAME_ALTERNATING_BARBELL_FORWARD_LUNGE ((FIT_LUNGE_EXERCISE_NAME)3) +#define FIT_LUNGE_EXERCISE_NAME_ALTERNATING_DUMBBELL_LUNGE_WITH_REACH ((FIT_LUNGE_EXERCISE_NAME)4) +#define FIT_LUNGE_EXERCISE_NAME_BACK_FOOT_ELEVATED_DUMBBELL_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)5) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)6) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_BULGARIAN_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)7) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_CROSSOVER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)8) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_FRONT_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)9) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)10) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_REVERSE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)11) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)12) +#define FIT_LUNGE_EXERCISE_NAME_BARBELL_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)13) +#define FIT_LUNGE_EXERCISE_NAME_CORE_CONTROL_REAR_LUNGE ((FIT_LUNGE_EXERCISE_NAME)14) +#define FIT_LUNGE_EXERCISE_NAME_DIAGONAL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)15) +#define FIT_LUNGE_EXERCISE_NAME_DROP_LUNGE ((FIT_LUNGE_EXERCISE_NAME)16) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)17) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_BULGARIAN_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)18) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_CROSSOVER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)19) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_DIAGONAL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)20) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)21) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_LUNGE_AND_ROTATION ((FIT_LUNGE_EXERCISE_NAME)22) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_OVERHEAD_BULGARIAN_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)23) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_REVERSE_LUNGE_TO_HIGH_KNEE_AND_PRESS ((FIT_LUNGE_EXERCISE_NAME)24) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)25) +#define FIT_LUNGE_EXERCISE_NAME_ELEVATED_FRONT_FOOT_BARBELL_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)26) +#define FIT_LUNGE_EXERCISE_NAME_FRONT_FOOT_ELEVATED_DUMBBELL_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)27) +#define FIT_LUNGE_EXERCISE_NAME_GUNSLINGER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)28) +#define FIT_LUNGE_EXERCISE_NAME_LAWNMOWER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)29) +#define FIT_LUNGE_EXERCISE_NAME_LOW_LUNGE_WITH_ISOMETRIC_ADDUCTION ((FIT_LUNGE_EXERCISE_NAME)30) +#define FIT_LUNGE_EXERCISE_NAME_LOW_SIDE_TO_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)31) +#define FIT_LUNGE_EXERCISE_NAME_LUNGE ((FIT_LUNGE_EXERCISE_NAME)32) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_LUNGE ((FIT_LUNGE_EXERCISE_NAME)33) +#define FIT_LUNGE_EXERCISE_NAME_LUNGE_WITH_ARM_REACH ((FIT_LUNGE_EXERCISE_NAME)34) +#define FIT_LUNGE_EXERCISE_NAME_LUNGE_WITH_DIAGONAL_REACH ((FIT_LUNGE_EXERCISE_NAME)35) +#define FIT_LUNGE_EXERCISE_NAME_LUNGE_WITH_SIDE_BEND ((FIT_LUNGE_EXERCISE_NAME)36) +#define FIT_LUNGE_EXERCISE_NAME_OFFSET_DUMBBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)37) +#define FIT_LUNGE_EXERCISE_NAME_OFFSET_DUMBBELL_REVERSE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)38) +#define FIT_LUNGE_EXERCISE_NAME_OVERHEAD_BULGARIAN_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)39) +#define FIT_LUNGE_EXERCISE_NAME_OVERHEAD_DUMBBELL_REVERSE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)40) +#define FIT_LUNGE_EXERCISE_NAME_OVERHEAD_DUMBBELL_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)41) +#define FIT_LUNGE_EXERCISE_NAME_OVERHEAD_LUNGE_WITH_ROTATION ((FIT_LUNGE_EXERCISE_NAME)42) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_BARBELL_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)43) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)44) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_DUMBBELL_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)45) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_DUMBBELL_CROSSOVER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)46) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_DUMBBELL_DIAGONAL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)47) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_LUNGE_WITH_REACH_BACK ((FIT_LUNGE_EXERCISE_NAME)48) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_REVERSE_LUNGE_WITH_REACH_BACK ((FIT_LUNGE_EXERCISE_NAME)49) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_LUNGE_WITH_TWIST_AND_OVERHEAD_REACH ((FIT_LUNGE_EXERCISE_NAME)50) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_REVERSE_LUNGE_WITH_TWIST_AND_OVERHEAD_REACH ((FIT_LUNGE_EXERCISE_NAME)51) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_SLIDING_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)52) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_REVERSE_SLIDING_BOX_LUNGE ((FIT_LUNGE_EXERCISE_NAME)53) +#define FIT_LUNGE_EXERCISE_NAME_REVERSE_SLIDING_LUNGE ((FIT_LUNGE_EXERCISE_NAME)54) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_REVERSE_SLIDING_LUNGE ((FIT_LUNGE_EXERCISE_NAME)55) +#define FIT_LUNGE_EXERCISE_NAME_RUNNERS_LUNGE_TO_BALANCE ((FIT_LUNGE_EXERCISE_NAME)56) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_RUNNERS_LUNGE_TO_BALANCE ((FIT_LUNGE_EXERCISE_NAME)57) +#define FIT_LUNGE_EXERCISE_NAME_SHIFTING_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)58) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_AND_CROSSOVER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)59) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_AND_CROSSOVER_LUNGE ((FIT_LUNGE_EXERCISE_NAME)60) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)61) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)62) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_LUNGE_AND_PRESS ((FIT_LUNGE_EXERCISE_NAME)63) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_LUNGE_JUMP_OFF ((FIT_LUNGE_EXERCISE_NAME)64) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_LUNGE_SWEEP ((FIT_LUNGE_EXERCISE_NAME)65) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_LUNGE_SWEEP ((FIT_LUNGE_EXERCISE_NAME)66) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_LUNGE_TO_CROSSOVER_TAP ((FIT_LUNGE_EXERCISE_NAME)67) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_LUNGE_TO_CROSSOVER_TAP ((FIT_LUNGE_EXERCISE_NAME)68) +#define FIT_LUNGE_EXERCISE_NAME_SIDE_TO_SIDE_LUNGE_CHOPS ((FIT_LUNGE_EXERCISE_NAME)69) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_TO_SIDE_LUNGE_CHOPS ((FIT_LUNGE_EXERCISE_NAME)70) +#define FIT_LUNGE_EXERCISE_NAME_SIFF_JUMP_LUNGE ((FIT_LUNGE_EXERCISE_NAME)71) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIFF_JUMP_LUNGE ((FIT_LUNGE_EXERCISE_NAME)72) +#define FIT_LUNGE_EXERCISE_NAME_SINGLE_ARM_REVERSE_LUNGE_AND_PRESS ((FIT_LUNGE_EXERCISE_NAME)73) +#define FIT_LUNGE_EXERCISE_NAME_SLIDING_LATERAL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)74) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SLIDING_LATERAL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)75) +#define FIT_LUNGE_EXERCISE_NAME_WALKING_BARBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)76) +#define FIT_LUNGE_EXERCISE_NAME_WALKING_DUMBBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)77) +#define FIT_LUNGE_EXERCISE_NAME_WALKING_LUNGE ((FIT_LUNGE_EXERCISE_NAME)78) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_WALKING_LUNGE ((FIT_LUNGE_EXERCISE_NAME)79) +#define FIT_LUNGE_EXERCISE_NAME_WIDE_GRIP_OVERHEAD_BARBELL_SPLIT_SQUAT ((FIT_LUNGE_EXERCISE_NAME)80) +#define FIT_LUNGE_EXERCISE_NAME_ALTERNATING_DUMBBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)81) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_REVERSE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)82) +#define FIT_LUNGE_EXERCISE_NAME_OVERHEAD_DUMBBELL_LUNGE ((FIT_LUNGE_EXERCISE_NAME)83) +#define FIT_LUNGE_EXERCISE_NAME_SCISSOR_POWER_SWITCH ((FIT_LUNGE_EXERCISE_NAME)84) +#define FIT_LUNGE_EXERCISE_NAME_DUMBBELL_OVERHEAD_WALKING_LUNGE ((FIT_LUNGE_EXERCISE_NAME)85) +#define FIT_LUNGE_EXERCISE_NAME_CURTSY_LUNGE ((FIT_LUNGE_EXERCISE_NAME)86) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_CURTSY_LUNGE ((FIT_LUNGE_EXERCISE_NAME)87) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SHIFTING_SIDE_LUNGE ((FIT_LUNGE_EXERCISE_NAME)88) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_LUNGE_AND_PRESS ((FIT_LUNGE_EXERCISE_NAME)89) +#define FIT_LUNGE_EXERCISE_NAME_WEIGHTED_SIDE_LUNGE_JUMP_OFF ((FIT_LUNGE_EXERCISE_NAME)90) +#define FIT_LUNGE_EXERCISE_NAME_COUNT 91 + +typedef FIT_UINT16 FIT_OLYMPIC_LIFT_EXERCISE_NAME; +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_HANG_POWER_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)0) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_HANG_SQUAT_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)1) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_POWER_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)2) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_POWER_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)3) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_SQUAT_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)4) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_CLEAN_AND_JERK ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)5) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_HANG_POWER_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)6) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_HANG_PULL ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)7) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_HIGH_PULL ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)8) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)9) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_BARBELL_SPLIT_JERK ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)10) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)11) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)12) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_HANG_PULL ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)13) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_ONE_HAND_DUMBBELL_SPLIT_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)14) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_PUSH_JERK ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)15) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_SINGLE_ARM_DUMBBELL_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)16) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_SINGLE_ARM_HANG_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)17) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_SINGLE_ARM_KETTLEBELL_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)18) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_SPLIT_JERK ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)19) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_SQUAT_CLEAN_AND_JERK ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)20) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_HANG_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)21) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_POWER_CLEAN_AND_JERK ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)22) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_POWER_CLEAN_AND_PUSH_PRESS ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)23) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_POWER_CLEAN_AND_STRICT_PRESS ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)24) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_DUMBBELL_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)25) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_MEDICINE_BALL_CLEAN ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)26) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_CLEAN_AND_PRESS ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)27) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_SNATCH ((FIT_OLYMPIC_LIFT_EXERCISE_NAME)28) +#define FIT_OLYMPIC_LIFT_EXERCISE_NAME_COUNT 29 + +typedef FIT_UINT16 FIT_PLANK_EXERCISE_NAME; +#define FIT_PLANK_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_PLANK_EXERCISE_NAME_45_DEGREE_PLANK ((FIT_PLANK_EXERCISE_NAME)0) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_45_DEGREE_PLANK ((FIT_PLANK_EXERCISE_NAME)1) +#define FIT_PLANK_EXERCISE_NAME_90_DEGREE_STATIC_HOLD ((FIT_PLANK_EXERCISE_NAME)2) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_90_DEGREE_STATIC_HOLD ((FIT_PLANK_EXERCISE_NAME)3) +#define FIT_PLANK_EXERCISE_NAME_BEAR_CRAWL ((FIT_PLANK_EXERCISE_NAME)4) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_BEAR_CRAWL ((FIT_PLANK_EXERCISE_NAME)5) +#define FIT_PLANK_EXERCISE_NAME_CROSS_BODY_MOUNTAIN_CLIMBER ((FIT_PLANK_EXERCISE_NAME)6) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_CROSS_BODY_MOUNTAIN_CLIMBER ((FIT_PLANK_EXERCISE_NAME)7) +#define FIT_PLANK_EXERCISE_NAME_ELBOW_PLANK_PIKE_JACKS ((FIT_PLANK_EXERCISE_NAME)8) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_ELBOW_PLANK_PIKE_JACKS ((FIT_PLANK_EXERCISE_NAME)9) +#define FIT_PLANK_EXERCISE_NAME_ELEVATED_FEET_PLANK ((FIT_PLANK_EXERCISE_NAME)10) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_ELEVATED_FEET_PLANK ((FIT_PLANK_EXERCISE_NAME)11) +#define FIT_PLANK_EXERCISE_NAME_ELEVATOR_ABS ((FIT_PLANK_EXERCISE_NAME)12) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_ELEVATOR_ABS ((FIT_PLANK_EXERCISE_NAME)13) +#define FIT_PLANK_EXERCISE_NAME_EXTENDED_PLANK ((FIT_PLANK_EXERCISE_NAME)14) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_EXTENDED_PLANK ((FIT_PLANK_EXERCISE_NAME)15) +#define FIT_PLANK_EXERCISE_NAME_FULL_PLANK_PASSE_TWIST ((FIT_PLANK_EXERCISE_NAME)16) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_FULL_PLANK_PASSE_TWIST ((FIT_PLANK_EXERCISE_NAME)17) +#define FIT_PLANK_EXERCISE_NAME_INCHING_ELBOW_PLANK ((FIT_PLANK_EXERCISE_NAME)18) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_INCHING_ELBOW_PLANK ((FIT_PLANK_EXERCISE_NAME)19) +#define FIT_PLANK_EXERCISE_NAME_INCHWORM_TO_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)20) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_INCHWORM_TO_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)21) +#define FIT_PLANK_EXERCISE_NAME_KNEELING_PLANK ((FIT_PLANK_EXERCISE_NAME)22) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_KNEELING_PLANK ((FIT_PLANK_EXERCISE_NAME)23) +#define FIT_PLANK_EXERCISE_NAME_KNEELING_SIDE_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)24) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_KNEELING_SIDE_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)25) +#define FIT_PLANK_EXERCISE_NAME_LATERAL_ROLL ((FIT_PLANK_EXERCISE_NAME)26) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_LATERAL_ROLL ((FIT_PLANK_EXERCISE_NAME)27) +#define FIT_PLANK_EXERCISE_NAME_LYING_REVERSE_PLANK ((FIT_PLANK_EXERCISE_NAME)28) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_LYING_REVERSE_PLANK ((FIT_PLANK_EXERCISE_NAME)29) +#define FIT_PLANK_EXERCISE_NAME_MEDICINE_BALL_MOUNTAIN_CLIMBER ((FIT_PLANK_EXERCISE_NAME)30) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MEDICINE_BALL_MOUNTAIN_CLIMBER ((FIT_PLANK_EXERCISE_NAME)31) +#define FIT_PLANK_EXERCISE_NAME_MODIFIED_MOUNTAIN_CLIMBER_AND_EXTENSION ((FIT_PLANK_EXERCISE_NAME)32) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MODIFIED_MOUNTAIN_CLIMBER_AND_EXTENSION ((FIT_PLANK_EXERCISE_NAME)33) +#define FIT_PLANK_EXERCISE_NAME_MOUNTAIN_CLIMBER ((FIT_PLANK_EXERCISE_NAME)34) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MOUNTAIN_CLIMBER ((FIT_PLANK_EXERCISE_NAME)35) +#define FIT_PLANK_EXERCISE_NAME_MOUNTAIN_CLIMBER_ON_SLIDING_DISCS ((FIT_PLANK_EXERCISE_NAME)36) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MOUNTAIN_CLIMBER_ON_SLIDING_DISCS ((FIT_PLANK_EXERCISE_NAME)37) +#define FIT_PLANK_EXERCISE_NAME_MOUNTAIN_CLIMBER_WITH_FEET_ON_BOSU_BALL ((FIT_PLANK_EXERCISE_NAME)38) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MOUNTAIN_CLIMBER_WITH_FEET_ON_BOSU_BALL ((FIT_PLANK_EXERCISE_NAME)39) +#define FIT_PLANK_EXERCISE_NAME_MOUNTAIN_CLIMBER_WITH_HANDS_ON_BENCH ((FIT_PLANK_EXERCISE_NAME)40) +#define FIT_PLANK_EXERCISE_NAME_MOUNTAIN_CLIMBER_WITH_HANDS_ON_SWISS_BALL ((FIT_PLANK_EXERCISE_NAME)41) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MOUNTAIN_CLIMBER_WITH_HANDS_ON_SWISS_BALL ((FIT_PLANK_EXERCISE_NAME)42) +#define FIT_PLANK_EXERCISE_NAME_PLANK ((FIT_PLANK_EXERCISE_NAME)43) +#define FIT_PLANK_EXERCISE_NAME_PLANK_JACKS_WITH_FEET_ON_SLIDING_DISCS ((FIT_PLANK_EXERCISE_NAME)44) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_JACKS_WITH_FEET_ON_SLIDING_DISCS ((FIT_PLANK_EXERCISE_NAME)45) +#define FIT_PLANK_EXERCISE_NAME_PLANK_KNEE_TWIST ((FIT_PLANK_EXERCISE_NAME)46) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_KNEE_TWIST ((FIT_PLANK_EXERCISE_NAME)47) +#define FIT_PLANK_EXERCISE_NAME_PLANK_PIKE_JUMPS ((FIT_PLANK_EXERCISE_NAME)48) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_PIKE_JUMPS ((FIT_PLANK_EXERCISE_NAME)49) +#define FIT_PLANK_EXERCISE_NAME_PLANK_PIKES ((FIT_PLANK_EXERCISE_NAME)50) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_PIKES ((FIT_PLANK_EXERCISE_NAME)51) +#define FIT_PLANK_EXERCISE_NAME_PLANK_TO_STAND_UP ((FIT_PLANK_EXERCISE_NAME)52) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_TO_STAND_UP ((FIT_PLANK_EXERCISE_NAME)53) +#define FIT_PLANK_EXERCISE_NAME_PLANK_WITH_ARM_RAISE ((FIT_PLANK_EXERCISE_NAME)54) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_WITH_ARM_RAISE ((FIT_PLANK_EXERCISE_NAME)55) +#define FIT_PLANK_EXERCISE_NAME_PLANK_WITH_KNEE_TO_ELBOW ((FIT_PLANK_EXERCISE_NAME)56) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_WITH_KNEE_TO_ELBOW ((FIT_PLANK_EXERCISE_NAME)57) +#define FIT_PLANK_EXERCISE_NAME_PLANK_WITH_OBLIQUE_CRUNCH ((FIT_PLANK_EXERCISE_NAME)58) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK_WITH_OBLIQUE_CRUNCH ((FIT_PLANK_EXERCISE_NAME)59) +#define FIT_PLANK_EXERCISE_NAME_PLYOMETRIC_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)60) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLYOMETRIC_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)61) +#define FIT_PLANK_EXERCISE_NAME_ROLLING_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)62) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_ROLLING_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)63) +#define FIT_PLANK_EXERCISE_NAME_SIDE_KICK_PLANK ((FIT_PLANK_EXERCISE_NAME)64) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_KICK_PLANK ((FIT_PLANK_EXERCISE_NAME)65) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)66) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)67) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_AND_ROW ((FIT_PLANK_EXERCISE_NAME)68) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_AND_ROW ((FIT_PLANK_EXERCISE_NAME)69) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_LIFT ((FIT_PLANK_EXERCISE_NAME)70) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_LIFT ((FIT_PLANK_EXERCISE_NAME)71) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_WITH_ELBOW_ON_BOSU_BALL ((FIT_PLANK_EXERCISE_NAME)72) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_WITH_ELBOW_ON_BOSU_BALL ((FIT_PLANK_EXERCISE_NAME)73) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_WITH_FEET_ON_BENCH ((FIT_PLANK_EXERCISE_NAME)74) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_WITH_FEET_ON_BENCH ((FIT_PLANK_EXERCISE_NAME)75) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_WITH_KNEE_CIRCLE ((FIT_PLANK_EXERCISE_NAME)76) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_WITH_KNEE_CIRCLE ((FIT_PLANK_EXERCISE_NAME)77) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_WITH_KNEE_TUCK ((FIT_PLANK_EXERCISE_NAME)78) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_WITH_KNEE_TUCK ((FIT_PLANK_EXERCISE_NAME)79) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)80) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)81) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_WITH_REACH_UNDER ((FIT_PLANK_EXERCISE_NAME)82) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SIDE_PLANK_WITH_REACH_UNDER ((FIT_PLANK_EXERCISE_NAME)83) +#define FIT_PLANK_EXERCISE_NAME_SINGLE_LEG_ELEVATED_FEET_PLANK ((FIT_PLANK_EXERCISE_NAME)84) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_ELEVATED_FEET_PLANK ((FIT_PLANK_EXERCISE_NAME)85) +#define FIT_PLANK_EXERCISE_NAME_SINGLE_LEG_FLEX_AND_EXTEND ((FIT_PLANK_EXERCISE_NAME)86) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_FLEX_AND_EXTEND ((FIT_PLANK_EXERCISE_NAME)87) +#define FIT_PLANK_EXERCISE_NAME_SINGLE_LEG_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)88) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)89) +#define FIT_PLANK_EXERCISE_NAME_SPIDERMAN_PLANK ((FIT_PLANK_EXERCISE_NAME)90) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SPIDERMAN_PLANK ((FIT_PLANK_EXERCISE_NAME)91) +#define FIT_PLANK_EXERCISE_NAME_STRAIGHT_ARM_PLANK ((FIT_PLANK_EXERCISE_NAME)92) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_STRAIGHT_ARM_PLANK ((FIT_PLANK_EXERCISE_NAME)93) +#define FIT_PLANK_EXERCISE_NAME_STRAIGHT_ARM_PLANK_WITH_SHOULDER_TOUCH ((FIT_PLANK_EXERCISE_NAME)94) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_STRAIGHT_ARM_PLANK_WITH_SHOULDER_TOUCH ((FIT_PLANK_EXERCISE_NAME)95) +#define FIT_PLANK_EXERCISE_NAME_SWISS_BALL_PLANK ((FIT_PLANK_EXERCISE_NAME)96) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PLANK ((FIT_PLANK_EXERCISE_NAME)97) +#define FIT_PLANK_EXERCISE_NAME_SWISS_BALL_PLANK_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)98) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PLANK_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)99) +#define FIT_PLANK_EXERCISE_NAME_SWISS_BALL_PLANK_LEG_LIFT_AND_HOLD ((FIT_PLANK_EXERCISE_NAME)100) +#define FIT_PLANK_EXERCISE_NAME_SWISS_BALL_PLANK_WITH_FEET_ON_BENCH ((FIT_PLANK_EXERCISE_NAME)101) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PLANK_WITH_FEET_ON_BENCH ((FIT_PLANK_EXERCISE_NAME)102) +#define FIT_PLANK_EXERCISE_NAME_SWISS_BALL_PRONE_JACKKNIFE ((FIT_PLANK_EXERCISE_NAME)103) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PRONE_JACKKNIFE ((FIT_PLANK_EXERCISE_NAME)104) +#define FIT_PLANK_EXERCISE_NAME_SWISS_BALL_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)105) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SWISS_BALL_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)106) +#define FIT_PLANK_EXERCISE_NAME_THREE_WAY_PLANK ((FIT_PLANK_EXERCISE_NAME)107) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_THREE_WAY_PLANK ((FIT_PLANK_EXERCISE_NAME)108) +#define FIT_PLANK_EXERCISE_NAME_TOWEL_PLANK_AND_KNEE_IN ((FIT_PLANK_EXERCISE_NAME)109) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_TOWEL_PLANK_AND_KNEE_IN ((FIT_PLANK_EXERCISE_NAME)110) +#define FIT_PLANK_EXERCISE_NAME_T_STABILIZATION ((FIT_PLANK_EXERCISE_NAME)111) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_T_STABILIZATION ((FIT_PLANK_EXERCISE_NAME)112) +#define FIT_PLANK_EXERCISE_NAME_TURKISH_GET_UP_TO_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)113) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_TURKISH_GET_UP_TO_SIDE_PLANK ((FIT_PLANK_EXERCISE_NAME)114) +#define FIT_PLANK_EXERCISE_NAME_TWO_POINT_PLANK ((FIT_PLANK_EXERCISE_NAME)115) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_TWO_POINT_PLANK ((FIT_PLANK_EXERCISE_NAME)116) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_PLANK ((FIT_PLANK_EXERCISE_NAME)117) +#define FIT_PLANK_EXERCISE_NAME_WIDE_STANCE_PLANK_WITH_DIAGONAL_ARM_LIFT ((FIT_PLANK_EXERCISE_NAME)118) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_WIDE_STANCE_PLANK_WITH_DIAGONAL_ARM_LIFT ((FIT_PLANK_EXERCISE_NAME)119) +#define FIT_PLANK_EXERCISE_NAME_WIDE_STANCE_PLANK_WITH_DIAGONAL_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)120) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_WIDE_STANCE_PLANK_WITH_DIAGONAL_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)121) +#define FIT_PLANK_EXERCISE_NAME_WIDE_STANCE_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)122) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_WIDE_STANCE_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)123) +#define FIT_PLANK_EXERCISE_NAME_WIDE_STANCE_PLANK_WITH_OPPOSITE_ARM_AND_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)124) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_MOUNTAIN_CLIMBER_WITH_HANDS_ON_BENCH ((FIT_PLANK_EXERCISE_NAME)125) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PLANK_LEG_LIFT_AND_HOLD ((FIT_PLANK_EXERCISE_NAME)126) +#define FIT_PLANK_EXERCISE_NAME_WEIGHTED_WIDE_STANCE_PLANK_WITH_OPPOSITE_ARM_AND_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)127) +#define FIT_PLANK_EXERCISE_NAME_PLANK_WITH_FEET_ON_SWISS_BALL ((FIT_PLANK_EXERCISE_NAME)128) +#define FIT_PLANK_EXERCISE_NAME_SIDE_PLANK_TO_PLANK_WITH_REACH_UNDER ((FIT_PLANK_EXERCISE_NAME)129) +#define FIT_PLANK_EXERCISE_NAME_BRIDGE_WITH_GLUTE_LOWER_LIFT ((FIT_PLANK_EXERCISE_NAME)130) +#define FIT_PLANK_EXERCISE_NAME_BRIDGE_ONE_LEG_BRIDGE ((FIT_PLANK_EXERCISE_NAME)131) +#define FIT_PLANK_EXERCISE_NAME_PLANK_WITH_ARM_VARIATIONS ((FIT_PLANK_EXERCISE_NAME)132) +#define FIT_PLANK_EXERCISE_NAME_PLANK_WITH_LEG_LIFT ((FIT_PLANK_EXERCISE_NAME)133) +#define FIT_PLANK_EXERCISE_NAME_REVERSE_PLANK_WITH_LEG_PULL ((FIT_PLANK_EXERCISE_NAME)134) +#define FIT_PLANK_EXERCISE_NAME_RING_PLANK_SPRAWLS ((FIT_PLANK_EXERCISE_NAME)135) +#define FIT_PLANK_EXERCISE_NAME_COUNT 136 + +typedef FIT_UINT16 FIT_PLYO_EXERCISE_NAME; +#define FIT_PLYO_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_PLYO_EXERCISE_NAME_ALTERNATING_JUMP_LUNGE ((FIT_PLYO_EXERCISE_NAME)0) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_ALTERNATING_JUMP_LUNGE ((FIT_PLYO_EXERCISE_NAME)1) +#define FIT_PLYO_EXERCISE_NAME_BARBELL_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)2) +#define FIT_PLYO_EXERCISE_NAME_BODY_WEIGHT_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)3) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)4) +#define FIT_PLYO_EXERCISE_NAME_CROSS_KNEE_STRIKE ((FIT_PLYO_EXERCISE_NAME)5) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_CROSS_KNEE_STRIKE ((FIT_PLYO_EXERCISE_NAME)6) +#define FIT_PLYO_EXERCISE_NAME_DEPTH_JUMP ((FIT_PLYO_EXERCISE_NAME)7) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_DEPTH_JUMP ((FIT_PLYO_EXERCISE_NAME)8) +#define FIT_PLYO_EXERCISE_NAME_DUMBBELL_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)9) +#define FIT_PLYO_EXERCISE_NAME_DUMBBELL_SPLIT_JUMP ((FIT_PLYO_EXERCISE_NAME)10) +#define FIT_PLYO_EXERCISE_NAME_FRONT_KNEE_STRIKE ((FIT_PLYO_EXERCISE_NAME)11) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_FRONT_KNEE_STRIKE ((FIT_PLYO_EXERCISE_NAME)12) +#define FIT_PLYO_EXERCISE_NAME_HIGH_BOX_JUMP ((FIT_PLYO_EXERCISE_NAME)13) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_HIGH_BOX_JUMP ((FIT_PLYO_EXERCISE_NAME)14) +#define FIT_PLYO_EXERCISE_NAME_ISOMETRIC_EXPLOSIVE_BODY_WEIGHT_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)15) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_ISOMETRIC_EXPLOSIVE_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)16) +#define FIT_PLYO_EXERCISE_NAME_LATERAL_LEAP_AND_HOP ((FIT_PLYO_EXERCISE_NAME)17) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_LATERAL_LEAP_AND_HOP ((FIT_PLYO_EXERCISE_NAME)18) +#define FIT_PLYO_EXERCISE_NAME_LATERAL_PLYO_SQUATS ((FIT_PLYO_EXERCISE_NAME)19) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_LATERAL_PLYO_SQUATS ((FIT_PLYO_EXERCISE_NAME)20) +#define FIT_PLYO_EXERCISE_NAME_LATERAL_SLIDE ((FIT_PLYO_EXERCISE_NAME)21) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_LATERAL_SLIDE ((FIT_PLYO_EXERCISE_NAME)22) +#define FIT_PLYO_EXERCISE_NAME_MEDICINE_BALL_OVERHEAD_THROWS ((FIT_PLYO_EXERCISE_NAME)23) +#define FIT_PLYO_EXERCISE_NAME_MEDICINE_BALL_SIDE_THROW ((FIT_PLYO_EXERCISE_NAME)24) +#define FIT_PLYO_EXERCISE_NAME_MEDICINE_BALL_SLAM ((FIT_PLYO_EXERCISE_NAME)25) +#define FIT_PLYO_EXERCISE_NAME_SIDE_TO_SIDE_MEDICINE_BALL_THROWS ((FIT_PLYO_EXERCISE_NAME)26) +#define FIT_PLYO_EXERCISE_NAME_SIDE_TO_SIDE_SHUFFLE_JUMP ((FIT_PLYO_EXERCISE_NAME)27) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_SIDE_TO_SIDE_SHUFFLE_JUMP ((FIT_PLYO_EXERCISE_NAME)28) +#define FIT_PLYO_EXERCISE_NAME_SQUAT_JUMP_ONTO_BOX ((FIT_PLYO_EXERCISE_NAME)29) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_SQUAT_JUMP_ONTO_BOX ((FIT_PLYO_EXERCISE_NAME)30) +#define FIT_PLYO_EXERCISE_NAME_SQUAT_JUMPS_IN_AND_OUT ((FIT_PLYO_EXERCISE_NAME)31) +#define FIT_PLYO_EXERCISE_NAME_WEIGHTED_SQUAT_JUMPS_IN_AND_OUT ((FIT_PLYO_EXERCISE_NAME)32) +#define FIT_PLYO_EXERCISE_NAME_BOX_JUMP ((FIT_PLYO_EXERCISE_NAME)33) +#define FIT_PLYO_EXERCISE_NAME_BOX_JUMP_OVERS ((FIT_PLYO_EXERCISE_NAME)34) +#define FIT_PLYO_EXERCISE_NAME_BOX_JUMP_OVERS_OVER_THE_BOX ((FIT_PLYO_EXERCISE_NAME)35) +#define FIT_PLYO_EXERCISE_NAME_STAR_JUMP_SQUATS ((FIT_PLYO_EXERCISE_NAME)36) +#define FIT_PLYO_EXERCISE_NAME_JUMP_SQUAT ((FIT_PLYO_EXERCISE_NAME)37) +#define FIT_PLYO_EXERCISE_NAME_COUNT 38 + +typedef FIT_UINT16 FIT_PULL_UP_EXERCISE_NAME; +#define FIT_PULL_UP_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_PULL_UP_EXERCISE_NAME_BANDED_PULL_UPS ((FIT_PULL_UP_EXERCISE_NAME)0) +#define FIT_PULL_UP_EXERCISE_NAME_30_DEGREE_LAT_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)1) +#define FIT_PULL_UP_EXERCISE_NAME_BAND_ASSISTED_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)2) +#define FIT_PULL_UP_EXERCISE_NAME_CLOSE_GRIP_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)3) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_CLOSE_GRIP_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)4) +#define FIT_PULL_UP_EXERCISE_NAME_CLOSE_GRIP_LAT_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)5) +#define FIT_PULL_UP_EXERCISE_NAME_CROSSOVER_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)6) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_CROSSOVER_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)7) +#define FIT_PULL_UP_EXERCISE_NAME_EZ_BAR_PULLOVER ((FIT_PULL_UP_EXERCISE_NAME)8) +#define FIT_PULL_UP_EXERCISE_NAME_HANGING_HURDLE ((FIT_PULL_UP_EXERCISE_NAME)9) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_HANGING_HURDLE ((FIT_PULL_UP_EXERCISE_NAME)10) +#define FIT_PULL_UP_EXERCISE_NAME_KNEELING_LAT_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)11) +#define FIT_PULL_UP_EXERCISE_NAME_KNEELING_UNDERHAND_GRIP_LAT_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)12) +#define FIT_PULL_UP_EXERCISE_NAME_LAT_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)13) +#define FIT_PULL_UP_EXERCISE_NAME_MIXED_GRIP_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)14) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_MIXED_GRIP_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)15) +#define FIT_PULL_UP_EXERCISE_NAME_MIXED_GRIP_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)16) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_MIXED_GRIP_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)17) +#define FIT_PULL_UP_EXERCISE_NAME_REVERSE_GRIP_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)18) +#define FIT_PULL_UP_EXERCISE_NAME_STANDING_CABLE_PULLOVER ((FIT_PULL_UP_EXERCISE_NAME)19) +#define FIT_PULL_UP_EXERCISE_NAME_STRAIGHT_ARM_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)20) +#define FIT_PULL_UP_EXERCISE_NAME_SWISS_BALL_EZ_BAR_PULLOVER ((FIT_PULL_UP_EXERCISE_NAME)21) +#define FIT_PULL_UP_EXERCISE_NAME_TOWEL_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)22) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_TOWEL_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)23) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)24) +#define FIT_PULL_UP_EXERCISE_NAME_WIDE_GRIP_LAT_PULLDOWN ((FIT_PULL_UP_EXERCISE_NAME)25) +#define FIT_PULL_UP_EXERCISE_NAME_WIDE_GRIP_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)26) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_WIDE_GRIP_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)27) +#define FIT_PULL_UP_EXERCISE_NAME_BURPEE_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)28) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_BURPEE_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)29) +#define FIT_PULL_UP_EXERCISE_NAME_JUMPING_PULL_UPS ((FIT_PULL_UP_EXERCISE_NAME)30) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_JUMPING_PULL_UPS ((FIT_PULL_UP_EXERCISE_NAME)31) +#define FIT_PULL_UP_EXERCISE_NAME_KIPPING_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)32) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_KIPPING_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)33) +#define FIT_PULL_UP_EXERCISE_NAME_L_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)34) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_L_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)35) +#define FIT_PULL_UP_EXERCISE_NAME_SUSPENDED_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)36) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_SUSPENDED_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)37) +#define FIT_PULL_UP_EXERCISE_NAME_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)38) +#define FIT_PULL_UP_EXERCISE_NAME_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)39) +#define FIT_PULL_UP_EXERCISE_NAME_NEUTRAL_GRIP_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)40) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)41) +#define FIT_PULL_UP_EXERCISE_NAME_BAND_ASSISTED_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)42) +#define FIT_PULL_UP_EXERCISE_NAME_NEUTRAL_GRIP_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)43) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_NEUTRAL_GRIP_CHIN_UP ((FIT_PULL_UP_EXERCISE_NAME)44) +#define FIT_PULL_UP_EXERCISE_NAME_WEIGHTED_NEUTRAL_GRIP_PULL_UP ((FIT_PULL_UP_EXERCISE_NAME)45) +#define FIT_PULL_UP_EXERCISE_NAME_COUNT 46 + +typedef FIT_UINT16 FIT_PUSH_UP_EXERCISE_NAME; +#define FIT_PUSH_UP_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_PUSH_UP_EXERCISE_NAME_CHEST_PRESS_WITH_BAND ((FIT_PUSH_UP_EXERCISE_NAME)0) +#define FIT_PUSH_UP_EXERCISE_NAME_ALTERNATING_STAGGERED_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)1) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_ALTERNATING_STAGGERED_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)2) +#define FIT_PUSH_UP_EXERCISE_NAME_ALTERNATING_HANDS_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)3) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_ALTERNATING_HANDS_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)4) +#define FIT_PUSH_UP_EXERCISE_NAME_BOSU_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)5) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_BOSU_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)6) +#define FIT_PUSH_UP_EXERCISE_NAME_CLAPPING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)7) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_CLAPPING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)8) +#define FIT_PUSH_UP_EXERCISE_NAME_CLOSE_GRIP_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)9) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_CLOSE_GRIP_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)10) +#define FIT_PUSH_UP_EXERCISE_NAME_CLOSE_HANDS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)11) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_CLOSE_HANDS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)12) +#define FIT_PUSH_UP_EXERCISE_NAME_DECLINE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)13) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_DECLINE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)14) +#define FIT_PUSH_UP_EXERCISE_NAME_DIAMOND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)15) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_DIAMOND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)16) +#define FIT_PUSH_UP_EXERCISE_NAME_EXPLOSIVE_CROSSOVER_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)17) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_EXPLOSIVE_CROSSOVER_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)18) +#define FIT_PUSH_UP_EXERCISE_NAME_EXPLOSIVE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)19) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_EXPLOSIVE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)20) +#define FIT_PUSH_UP_EXERCISE_NAME_FEET_ELEVATED_SIDE_TO_SIDE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)21) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_FEET_ELEVATED_SIDE_TO_SIDE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)22) +#define FIT_PUSH_UP_EXERCISE_NAME_HAND_RELEASE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)23) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_HAND_RELEASE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)24) +#define FIT_PUSH_UP_EXERCISE_NAME_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)25) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)26) +#define FIT_PUSH_UP_EXERCISE_NAME_INCLINE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)27) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_INCLINE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)28) +#define FIT_PUSH_UP_EXERCISE_NAME_ISOMETRIC_EXPLOSIVE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)29) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_ISOMETRIC_EXPLOSIVE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)30) +#define FIT_PUSH_UP_EXERCISE_NAME_JUDO_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)31) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_JUDO_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)32) +#define FIT_PUSH_UP_EXERCISE_NAME_KNEELING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)33) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_KNEELING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)34) +#define FIT_PUSH_UP_EXERCISE_NAME_MEDICINE_BALL_CHEST_PASS ((FIT_PUSH_UP_EXERCISE_NAME)35) +#define FIT_PUSH_UP_EXERCISE_NAME_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)36) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)37) +#define FIT_PUSH_UP_EXERCISE_NAME_ONE_ARM_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)38) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_ONE_ARM_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)39) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)40) +#define FIT_PUSH_UP_EXERCISE_NAME_PUSH_UP_AND_ROW ((FIT_PUSH_UP_EXERCISE_NAME)41) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PUSH_UP_AND_ROW ((FIT_PUSH_UP_EXERCISE_NAME)42) +#define FIT_PUSH_UP_EXERCISE_NAME_PUSH_UP_PLUS ((FIT_PUSH_UP_EXERCISE_NAME)43) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PUSH_UP_PLUS ((FIT_PUSH_UP_EXERCISE_NAME)44) +#define FIT_PUSH_UP_EXERCISE_NAME_PUSH_UP_WITH_FEET_ON_SWISS_BALL ((FIT_PUSH_UP_EXERCISE_NAME)45) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PUSH_UP_WITH_FEET_ON_SWISS_BALL ((FIT_PUSH_UP_EXERCISE_NAME)46) +#define FIT_PUSH_UP_EXERCISE_NAME_PUSH_UP_WITH_ONE_HAND_ON_MEDICINE_BALL ((FIT_PUSH_UP_EXERCISE_NAME)47) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PUSH_UP_WITH_ONE_HAND_ON_MEDICINE_BALL ((FIT_PUSH_UP_EXERCISE_NAME)48) +#define FIT_PUSH_UP_EXERCISE_NAME_SHOULDER_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)49) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_SHOULDER_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)50) +#define FIT_PUSH_UP_EXERCISE_NAME_SINGLE_ARM_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)51) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_SINGLE_ARM_MEDICINE_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)52) +#define FIT_PUSH_UP_EXERCISE_NAME_SPIDERMAN_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)53) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_SPIDERMAN_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)54) +#define FIT_PUSH_UP_EXERCISE_NAME_STACKED_FEET_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)55) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_STACKED_FEET_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)56) +#define FIT_PUSH_UP_EXERCISE_NAME_STAGGERED_HANDS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)57) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_STAGGERED_HANDS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)58) +#define FIT_PUSH_UP_EXERCISE_NAME_SUSPENDED_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)59) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_SUSPENDED_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)60) +#define FIT_PUSH_UP_EXERCISE_NAME_SWISS_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)61) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)62) +#define FIT_PUSH_UP_EXERCISE_NAME_SWISS_BALL_PUSH_UP_PLUS ((FIT_PUSH_UP_EXERCISE_NAME)63) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_SWISS_BALL_PUSH_UP_PLUS ((FIT_PUSH_UP_EXERCISE_NAME)64) +#define FIT_PUSH_UP_EXERCISE_NAME_T_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)65) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_T_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)66) +#define FIT_PUSH_UP_EXERCISE_NAME_TRIPLE_STOP_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)67) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_TRIPLE_STOP_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)68) +#define FIT_PUSH_UP_EXERCISE_NAME_WIDE_HANDS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)69) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_WIDE_HANDS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)70) +#define FIT_PUSH_UP_EXERCISE_NAME_PARALLETTE_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)71) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PARALLETTE_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)72) +#define FIT_PUSH_UP_EXERCISE_NAME_RING_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)73) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_RING_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)74) +#define FIT_PUSH_UP_EXERCISE_NAME_RING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)75) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_RING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)76) +#define FIT_PUSH_UP_EXERCISE_NAME_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)77) +#define FIT_PUSH_UP_EXERCISE_NAME_PILATES_PUSHUP ((FIT_PUSH_UP_EXERCISE_NAME)78) +#define FIT_PUSH_UP_EXERCISE_NAME_DYNAMIC_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)79) +#define FIT_PUSH_UP_EXERCISE_NAME_KIPPING_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)80) +#define FIT_PUSH_UP_EXERCISE_NAME_SHOULDER_TAPPING_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)81) +#define FIT_PUSH_UP_EXERCISE_NAME_BICEPS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)82) +#define FIT_PUSH_UP_EXERCISE_NAME_HINDU_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)83) +#define FIT_PUSH_UP_EXERCISE_NAME_PIKE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)84) +#define FIT_PUSH_UP_EXERCISE_NAME_WIDE_GRIP_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)85) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_BICEPS_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)86) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_HINDU_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)87) +#define FIT_PUSH_UP_EXERCISE_NAME_WEIGHTED_PIKE_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)88) +#define FIT_PUSH_UP_EXERCISE_NAME_KIPPING_PARALLETTE_HANDSTAND_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)89) +#define FIT_PUSH_UP_EXERCISE_NAME_WALL_PUSH_UP ((FIT_PUSH_UP_EXERCISE_NAME)90) +#define FIT_PUSH_UP_EXERCISE_NAME_COUNT 91 + +typedef FIT_UINT16 FIT_ROW_EXERCISE_NAME; +#define FIT_ROW_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_ROW_EXERCISE_NAME_BARBELL_STRAIGHT_LEG_DEADLIFT_TO_ROW ((FIT_ROW_EXERCISE_NAME)0) +#define FIT_ROW_EXERCISE_NAME_CABLE_ROW_STANDING ((FIT_ROW_EXERCISE_NAME)1) +#define FIT_ROW_EXERCISE_NAME_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)2) +#define FIT_ROW_EXERCISE_NAME_ELEVATED_FEET_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)3) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_ELEVATED_FEET_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)4) +#define FIT_ROW_EXERCISE_NAME_FACE_PULL ((FIT_ROW_EXERCISE_NAME)5) +#define FIT_ROW_EXERCISE_NAME_FACE_PULL_WITH_EXTERNAL_ROTATION ((FIT_ROW_EXERCISE_NAME)6) +#define FIT_ROW_EXERCISE_NAME_INVERTED_ROW_WITH_FEET_ON_SWISS_BALL ((FIT_ROW_EXERCISE_NAME)7) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_INVERTED_ROW_WITH_FEET_ON_SWISS_BALL ((FIT_ROW_EXERCISE_NAME)8) +#define FIT_ROW_EXERCISE_NAME_KETTLEBELL_ROW ((FIT_ROW_EXERCISE_NAME)9) +#define FIT_ROW_EXERCISE_NAME_MODIFIED_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)10) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_MODIFIED_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)11) +#define FIT_ROW_EXERCISE_NAME_NEUTRAL_GRIP_ALTERNATING_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)12) +#define FIT_ROW_EXERCISE_NAME_ONE_ARM_BENT_OVER_ROW ((FIT_ROW_EXERCISE_NAME)13) +#define FIT_ROW_EXERCISE_NAME_ONE_LEGGED_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)14) +#define FIT_ROW_EXERCISE_NAME_RENEGADE_ROW ((FIT_ROW_EXERCISE_NAME)15) +#define FIT_ROW_EXERCISE_NAME_REVERSE_GRIP_BARBELL_ROW ((FIT_ROW_EXERCISE_NAME)16) +#define FIT_ROW_EXERCISE_NAME_ROPE_HANDLE_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)17) +#define FIT_ROW_EXERCISE_NAME_SEATED_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)18) +#define FIT_ROW_EXERCISE_NAME_SEATED_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)19) +#define FIT_ROW_EXERCISE_NAME_SINGLE_ARM_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)20) +#define FIT_ROW_EXERCISE_NAME_SINGLE_ARM_CABLE_ROW_AND_ROTATION ((FIT_ROW_EXERCISE_NAME)21) +#define FIT_ROW_EXERCISE_NAME_SINGLE_ARM_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)22) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_SINGLE_ARM_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)23) +#define FIT_ROW_EXERCISE_NAME_SINGLE_ARM_NEUTRAL_GRIP_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)24) +#define FIT_ROW_EXERCISE_NAME_SINGLE_ARM_NEUTRAL_GRIP_DUMBBELL_ROW_AND_ROTATION ((FIT_ROW_EXERCISE_NAME)25) +#define FIT_ROW_EXERCISE_NAME_SUSPENDED_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)26) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_SUSPENDED_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)27) +#define FIT_ROW_EXERCISE_NAME_T_BAR_ROW ((FIT_ROW_EXERCISE_NAME)28) +#define FIT_ROW_EXERCISE_NAME_TOWEL_GRIP_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)29) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_TOWEL_GRIP_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)30) +#define FIT_ROW_EXERCISE_NAME_UNDERHAND_GRIP_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)31) +#define FIT_ROW_EXERCISE_NAME_V_GRIP_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)32) +#define FIT_ROW_EXERCISE_NAME_WIDE_GRIP_SEATED_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)33) +#define FIT_ROW_EXERCISE_NAME_ALTERNATING_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)34) +#define FIT_ROW_EXERCISE_NAME_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)35) +#define FIT_ROW_EXERCISE_NAME_ROW ((FIT_ROW_EXERCISE_NAME)36) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_ROW ((FIT_ROW_EXERCISE_NAME)37) +#define FIT_ROW_EXERCISE_NAME_INDOOR_ROW ((FIT_ROW_EXERCISE_NAME)38) +#define FIT_ROW_EXERCISE_NAME_BANDED_FACE_PULLS ((FIT_ROW_EXERCISE_NAME)39) +#define FIT_ROW_EXERCISE_NAME_CHEST_SUPPORTED_DUMBBELL_ROW ((FIT_ROW_EXERCISE_NAME)40) +#define FIT_ROW_EXERCISE_NAME_DECLINE_RING_ROW ((FIT_ROW_EXERCISE_NAME)41) +#define FIT_ROW_EXERCISE_NAME_ELEVATED_RING_ROW ((FIT_ROW_EXERCISE_NAME)42) +#define FIT_ROW_EXERCISE_NAME_RDL_BENT_OVER_ROW_WITH_BARBELL_DUMBBELL ((FIT_ROW_EXERCISE_NAME)43) +#define FIT_ROW_EXERCISE_NAME_RING_ROW ((FIT_ROW_EXERCISE_NAME)44) +#define FIT_ROW_EXERCISE_NAME_BARBELL_ROW ((FIT_ROW_EXERCISE_NAME)45) +#define FIT_ROW_EXERCISE_NAME_BENT_OVER_ROW_WITH_BARBELL ((FIT_ROW_EXERCISE_NAME)46) +#define FIT_ROW_EXERCISE_NAME_BENT_OVER_ROW_WITH_DUMBELL ((FIT_ROW_EXERCISE_NAME)47) +#define FIT_ROW_EXERCISE_NAME_SEATED_UNDERHAND_GRIP_CABLE_ROW ((FIT_ROW_EXERCISE_NAME)48) +#define FIT_ROW_EXERCISE_NAME_TRX_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)49) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)50) +#define FIT_ROW_EXERCISE_NAME_WEIGHTED_TRX_INVERTED_ROW ((FIT_ROW_EXERCISE_NAME)51) +#define FIT_ROW_EXERCISE_NAME_DUMBBELL_ROW_WHEELCHAIR ((FIT_ROW_EXERCISE_NAME)52) +#define FIT_ROW_EXERCISE_NAME_COUNT 53 + +typedef FIT_UINT16 FIT_SHOULDER_PRESS_EXERCISE_NAME; +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_ALTERNATING_DUMBBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)0) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_ARNOLD_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)1) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_BARBELL_FRONT_SQUAT_TO_PUSH_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)2) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_BARBELL_PUSH_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)3) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_BARBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)4) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DEAD_CURL_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)5) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DUMBBELL_ALTERNATING_SHOULDER_PRESS_AND_TWIST ((FIT_SHOULDER_PRESS_EXERCISE_NAME)6) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DUMBBELL_HAMMER_CURL_TO_LUNGE_TO_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)7) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DUMBBELL_PUSH_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)8) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_FLOOR_INVERTED_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)9) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_WEIGHTED_FLOOR_INVERTED_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)10) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_INVERTED_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)11) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_WEIGHTED_INVERTED_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)12) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_ONE_ARM_PUSH_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)13) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_OVERHEAD_BARBELL_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)14) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_OVERHEAD_DUMBBELL_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)15) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SEATED_BARBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)16) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SEATED_DUMBBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)17) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SINGLE_ARM_DUMBBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)18) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SINGLE_ARM_STEP_UP_AND_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)19) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SMITH_MACHINE_OVERHEAD_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)20) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SPLIT_STANCE_HAMMER_CURL_TO_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)21) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_SWISS_BALL_DUMBBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)22) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_WEIGHT_PLATE_FRONT_RAISE ((FIT_SHOULDER_PRESS_EXERCISE_NAME)23) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DUMBBELL_SHOULDER_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)24) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_MILITARY_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)25) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_STRICT_PRESS ((FIT_SHOULDER_PRESS_EXERCISE_NAME)27) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DUMBBELL_FRONT_RAISE ((FIT_SHOULDER_PRESS_EXERCISE_NAME)28) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_DUMBBELL_CURL_TO_OVERHEAD_PRESS_WHEELCHAIR ((FIT_SHOULDER_PRESS_EXERCISE_NAME)29) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_ARNOLD_PRESS_WHEELCHAIR ((FIT_SHOULDER_PRESS_EXERCISE_NAME)30) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_OVERHEAD_DUMBBELL_PRESS_WHEELCHAIR ((FIT_SHOULDER_PRESS_EXERCISE_NAME)31) +#define FIT_SHOULDER_PRESS_EXERCISE_NAME_COUNT 31 + +typedef FIT_UINT16 FIT_SHOULDER_STABILITY_EXERCISE_NAME; +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_90_DEGREE_CABLE_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)0) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_BAND_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)1) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_BAND_INTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)2) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_BENT_ARM_LATERAL_RAISE_AND_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)3) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_CABLE_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)4) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_DUMBBELL_FACE_PULL_WITH_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)5) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_FLOOR_I_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)6) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_FLOOR_I_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)7) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_FLOOR_T_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)8) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_FLOOR_T_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)9) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_FLOOR_Y_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)10) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_FLOOR_Y_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)11) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_INCLINE_I_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)12) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_INCLINE_I_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)13) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_INCLINE_L_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)14) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_INCLINE_L_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)15) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_INCLINE_T_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)16) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_INCLINE_T_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)17) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_INCLINE_W_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)18) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_INCLINE_W_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)19) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_INCLINE_Y_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)20) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_INCLINE_Y_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)21) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_LYING_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)22) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_SEATED_DUMBBELL_EXTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)23) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_STANDING_L_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)24) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_SWISS_BALL_I_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)25) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_SWISS_BALL_I_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)26) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_SWISS_BALL_T_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)27) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_SWISS_BALL_T_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)28) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_SWISS_BALL_W_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)29) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_SWISS_BALL_W_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)30) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_SWISS_BALL_Y_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)31) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_WEIGHTED_SWISS_BALL_Y_RAISE ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)32) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_CABLE_INTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)33) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_LYING_INTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)34) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_SEATED_DUMBBELL_INTERNAL_ROTATION ((FIT_SHOULDER_STABILITY_EXERCISE_NAME)35) +#define FIT_SHOULDER_STABILITY_EXERCISE_NAME_COUNT 36 + +typedef FIT_UINT16 FIT_SHRUG_EXERCISE_NAME; +#define FIT_SHRUG_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SHRUG_EXERCISE_NAME_BARBELL_JUMP_SHRUG ((FIT_SHRUG_EXERCISE_NAME)0) +#define FIT_SHRUG_EXERCISE_NAME_BARBELL_SHRUG ((FIT_SHRUG_EXERCISE_NAME)1) +#define FIT_SHRUG_EXERCISE_NAME_BARBELL_UPRIGHT_ROW ((FIT_SHRUG_EXERCISE_NAME)2) +#define FIT_SHRUG_EXERCISE_NAME_BEHIND_THE_BACK_SMITH_MACHINE_SHRUG ((FIT_SHRUG_EXERCISE_NAME)3) +#define FIT_SHRUG_EXERCISE_NAME_DUMBBELL_JUMP_SHRUG ((FIT_SHRUG_EXERCISE_NAME)4) +#define FIT_SHRUG_EXERCISE_NAME_DUMBBELL_SHRUG ((FIT_SHRUG_EXERCISE_NAME)5) +#define FIT_SHRUG_EXERCISE_NAME_DUMBBELL_UPRIGHT_ROW ((FIT_SHRUG_EXERCISE_NAME)6) +#define FIT_SHRUG_EXERCISE_NAME_INCLINE_DUMBBELL_SHRUG ((FIT_SHRUG_EXERCISE_NAME)7) +#define FIT_SHRUG_EXERCISE_NAME_OVERHEAD_BARBELL_SHRUG ((FIT_SHRUG_EXERCISE_NAME)8) +#define FIT_SHRUG_EXERCISE_NAME_OVERHEAD_DUMBBELL_SHRUG ((FIT_SHRUG_EXERCISE_NAME)9) +#define FIT_SHRUG_EXERCISE_NAME_SCAPTION_AND_SHRUG ((FIT_SHRUG_EXERCISE_NAME)10) +#define FIT_SHRUG_EXERCISE_NAME_SCAPULAR_RETRACTION ((FIT_SHRUG_EXERCISE_NAME)11) +#define FIT_SHRUG_EXERCISE_NAME_SERRATUS_CHAIR_SHRUG ((FIT_SHRUG_EXERCISE_NAME)12) +#define FIT_SHRUG_EXERCISE_NAME_WEIGHTED_SERRATUS_CHAIR_SHRUG ((FIT_SHRUG_EXERCISE_NAME)13) +#define FIT_SHRUG_EXERCISE_NAME_SERRATUS_SHRUG ((FIT_SHRUG_EXERCISE_NAME)14) +#define FIT_SHRUG_EXERCISE_NAME_WEIGHTED_SERRATUS_SHRUG ((FIT_SHRUG_EXERCISE_NAME)15) +#define FIT_SHRUG_EXERCISE_NAME_WIDE_GRIP_JUMP_SHRUG ((FIT_SHRUG_EXERCISE_NAME)16) +#define FIT_SHRUG_EXERCISE_NAME_WIDE_GRIP_BARBELL_SHRUG ((FIT_SHRUG_EXERCISE_NAME)17) +#define FIT_SHRUG_EXERCISE_NAME_BEHIND_THE_BACK_SHRUG ((FIT_SHRUG_EXERCISE_NAME)18) +#define FIT_SHRUG_EXERCISE_NAME_DUMBBELL_SHRUG_WHEELCHAIR ((FIT_SHRUG_EXERCISE_NAME)19) +#define FIT_SHRUG_EXERCISE_NAME_SHRUG_WHEELCHAIR ((FIT_SHRUG_EXERCISE_NAME)20) +#define FIT_SHRUG_EXERCISE_NAME_SHRUG_ARM_DOWN_WHEELCHAIR ((FIT_SHRUG_EXERCISE_NAME)21) +#define FIT_SHRUG_EXERCISE_NAME_SHRUG_ARM_MID_WHEELCHAIR ((FIT_SHRUG_EXERCISE_NAME)22) +#define FIT_SHRUG_EXERCISE_NAME_SHRUG_ARM_UP_WHEELCHAIR ((FIT_SHRUG_EXERCISE_NAME)23) +#define FIT_SHRUG_EXERCISE_NAME_UPRIGHT_ROW ((FIT_SHRUG_EXERCISE_NAME)24) +#define FIT_SHRUG_EXERCISE_NAME_COUNT 25 + +typedef FIT_UINT16 FIT_SIT_UP_EXERCISE_NAME; +#define FIT_SIT_UP_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SIT_UP_EXERCISE_NAME_ALTERNATING_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)0) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_ALTERNATING_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)1) +#define FIT_SIT_UP_EXERCISE_NAME_BENT_KNEE_V_UP ((FIT_SIT_UP_EXERCISE_NAME)2) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_BENT_KNEE_V_UP ((FIT_SIT_UP_EXERCISE_NAME)3) +#define FIT_SIT_UP_EXERCISE_NAME_BUTTERFLY_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)4) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_BUTTERFLY_SITUP ((FIT_SIT_UP_EXERCISE_NAME)5) +#define FIT_SIT_UP_EXERCISE_NAME_CROSS_PUNCH_ROLL_UP ((FIT_SIT_UP_EXERCISE_NAME)6) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_CROSS_PUNCH_ROLL_UP ((FIT_SIT_UP_EXERCISE_NAME)7) +#define FIT_SIT_UP_EXERCISE_NAME_CROSSED_ARMS_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)8) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_CROSSED_ARMS_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)9) +#define FIT_SIT_UP_EXERCISE_NAME_GET_UP_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)10) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_GET_UP_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)11) +#define FIT_SIT_UP_EXERCISE_NAME_HOVERING_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)12) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_HOVERING_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)13) +#define FIT_SIT_UP_EXERCISE_NAME_KETTLEBELL_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)14) +#define FIT_SIT_UP_EXERCISE_NAME_MEDICINE_BALL_ALTERNATING_V_UP ((FIT_SIT_UP_EXERCISE_NAME)15) +#define FIT_SIT_UP_EXERCISE_NAME_MEDICINE_BALL_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)16) +#define FIT_SIT_UP_EXERCISE_NAME_MEDICINE_BALL_V_UP ((FIT_SIT_UP_EXERCISE_NAME)17) +#define FIT_SIT_UP_EXERCISE_NAME_MODIFIED_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)18) +#define FIT_SIT_UP_EXERCISE_NAME_NEGATIVE_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)19) +#define FIT_SIT_UP_EXERCISE_NAME_ONE_ARM_FULL_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)20) +#define FIT_SIT_UP_EXERCISE_NAME_RECLINING_CIRCLE ((FIT_SIT_UP_EXERCISE_NAME)21) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_RECLINING_CIRCLE ((FIT_SIT_UP_EXERCISE_NAME)22) +#define FIT_SIT_UP_EXERCISE_NAME_REVERSE_CURL_UP ((FIT_SIT_UP_EXERCISE_NAME)23) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_REVERSE_CURL_UP ((FIT_SIT_UP_EXERCISE_NAME)24) +#define FIT_SIT_UP_EXERCISE_NAME_SINGLE_LEG_SWISS_BALL_JACKKNIFE ((FIT_SIT_UP_EXERCISE_NAME)25) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_SWISS_BALL_JACKKNIFE ((FIT_SIT_UP_EXERCISE_NAME)26) +#define FIT_SIT_UP_EXERCISE_NAME_THE_TEASER ((FIT_SIT_UP_EXERCISE_NAME)27) +#define FIT_SIT_UP_EXERCISE_NAME_THE_TEASER_WEIGHTED ((FIT_SIT_UP_EXERCISE_NAME)28) +#define FIT_SIT_UP_EXERCISE_NAME_THREE_PART_ROLL_DOWN ((FIT_SIT_UP_EXERCISE_NAME)29) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_THREE_PART_ROLL_DOWN ((FIT_SIT_UP_EXERCISE_NAME)30) +#define FIT_SIT_UP_EXERCISE_NAME_V_UP ((FIT_SIT_UP_EXERCISE_NAME)31) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_V_UP ((FIT_SIT_UP_EXERCISE_NAME)32) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_RUSSIAN_TWIST_ON_SWISS_BALL ((FIT_SIT_UP_EXERCISE_NAME)33) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)34) +#define FIT_SIT_UP_EXERCISE_NAME_X_ABS ((FIT_SIT_UP_EXERCISE_NAME)35) +#define FIT_SIT_UP_EXERCISE_NAME_WEIGHTED_X_ABS ((FIT_SIT_UP_EXERCISE_NAME)36) +#define FIT_SIT_UP_EXERCISE_NAME_SIT_UP ((FIT_SIT_UP_EXERCISE_NAME)37) +#define FIT_SIT_UP_EXERCISE_NAME_GHD_SIT_UPS ((FIT_SIT_UP_EXERCISE_NAME)38) +#define FIT_SIT_UP_EXERCISE_NAME_SIT_UP_TURKISH_GET_UP ((FIT_SIT_UP_EXERCISE_NAME)39) +#define FIT_SIT_UP_EXERCISE_NAME_RUSSIAN_TWIST_ON_SWISS_BALL ((FIT_SIT_UP_EXERCISE_NAME)40) +#define FIT_SIT_UP_EXERCISE_NAME_COUNT 41 + +typedef FIT_UINT16 FIT_SQUAT_EXERCISE_NAME; +#define FIT_SQUAT_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SQUAT_EXERCISE_NAME_LEG_PRESS ((FIT_SQUAT_EXERCISE_NAME)0) +#define FIT_SQUAT_EXERCISE_NAME_BACK_SQUAT_WITH_BODY_BAR ((FIT_SQUAT_EXERCISE_NAME)1) +#define FIT_SQUAT_EXERCISE_NAME_BACK_SQUATS ((FIT_SQUAT_EXERCISE_NAME)2) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_BACK_SQUATS ((FIT_SQUAT_EXERCISE_NAME)3) +#define FIT_SQUAT_EXERCISE_NAME_BALANCING_SQUAT ((FIT_SQUAT_EXERCISE_NAME)4) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_BALANCING_SQUAT ((FIT_SQUAT_EXERCISE_NAME)5) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_BACK_SQUAT ((FIT_SQUAT_EXERCISE_NAME)6) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_BOX_SQUAT ((FIT_SQUAT_EXERCISE_NAME)7) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_FRONT_SQUAT ((FIT_SQUAT_EXERCISE_NAME)8) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_HACK_SQUAT ((FIT_SQUAT_EXERCISE_NAME)9) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_HANG_SQUAT_SNATCH ((FIT_SQUAT_EXERCISE_NAME)10) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_LATERAL_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)11) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_QUARTER_SQUAT ((FIT_SQUAT_EXERCISE_NAME)12) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_SIFF_SQUAT ((FIT_SQUAT_EXERCISE_NAME)13) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_SQUAT_SNATCH ((FIT_SQUAT_EXERCISE_NAME)14) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_SQUAT_WITH_HEELS_RAISED ((FIT_SQUAT_EXERCISE_NAME)15) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_STEPOVER ((FIT_SQUAT_EXERCISE_NAME)16) +#define FIT_SQUAT_EXERCISE_NAME_BARBELL_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)17) +#define FIT_SQUAT_EXERCISE_NAME_BENCH_SQUAT_WITH_ROTATIONAL_CHOP ((FIT_SQUAT_EXERCISE_NAME)18) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_BENCH_SQUAT_WITH_ROTATIONAL_CHOP ((FIT_SQUAT_EXERCISE_NAME)19) +#define FIT_SQUAT_EXERCISE_NAME_BODY_WEIGHT_WALL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)20) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_WALL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)21) +#define FIT_SQUAT_EXERCISE_NAME_BOX_STEP_SQUAT ((FIT_SQUAT_EXERCISE_NAME)22) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_BOX_STEP_SQUAT ((FIT_SQUAT_EXERCISE_NAME)23) +#define FIT_SQUAT_EXERCISE_NAME_BRACED_SQUAT ((FIT_SQUAT_EXERCISE_NAME)24) +#define FIT_SQUAT_EXERCISE_NAME_CROSSED_ARM_BARBELL_FRONT_SQUAT ((FIT_SQUAT_EXERCISE_NAME)25) +#define FIT_SQUAT_EXERCISE_NAME_CROSSOVER_DUMBBELL_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)26) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_FRONT_SQUAT ((FIT_SQUAT_EXERCISE_NAME)27) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_SPLIT_SQUAT ((FIT_SQUAT_EXERCISE_NAME)28) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)29) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_SQUAT_CLEAN ((FIT_SQUAT_EXERCISE_NAME)30) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_STEPOVER ((FIT_SQUAT_EXERCISE_NAME)31) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)32) +#define FIT_SQUAT_EXERCISE_NAME_ELEVATED_SINGLE_LEG_SQUAT ((FIT_SQUAT_EXERCISE_NAME)33) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_ELEVATED_SINGLE_LEG_SQUAT ((FIT_SQUAT_EXERCISE_NAME)34) +#define FIT_SQUAT_EXERCISE_NAME_FIGURE_FOUR_SQUATS ((FIT_SQUAT_EXERCISE_NAME)35) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_FIGURE_FOUR_SQUATS ((FIT_SQUAT_EXERCISE_NAME)36) +#define FIT_SQUAT_EXERCISE_NAME_GOBLET_SQUAT ((FIT_SQUAT_EXERCISE_NAME)37) +#define FIT_SQUAT_EXERCISE_NAME_KETTLEBELL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)38) +#define FIT_SQUAT_EXERCISE_NAME_KETTLEBELL_SWING_OVERHEAD ((FIT_SQUAT_EXERCISE_NAME)39) +#define FIT_SQUAT_EXERCISE_NAME_KETTLEBELL_SWING_WITH_FLIP_TO_SQUAT ((FIT_SQUAT_EXERCISE_NAME)40) +#define FIT_SQUAT_EXERCISE_NAME_LATERAL_DUMBBELL_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)41) +#define FIT_SQUAT_EXERCISE_NAME_ONE_LEGGED_SQUAT ((FIT_SQUAT_EXERCISE_NAME)42) +#define FIT_SQUAT_EXERCISE_NAME_OVERHEAD_DUMBBELL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)43) +#define FIT_SQUAT_EXERCISE_NAME_OVERHEAD_SQUAT ((FIT_SQUAT_EXERCISE_NAME)44) +#define FIT_SQUAT_EXERCISE_NAME_PARTIAL_SINGLE_LEG_SQUAT ((FIT_SQUAT_EXERCISE_NAME)45) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_PARTIAL_SINGLE_LEG_SQUAT ((FIT_SQUAT_EXERCISE_NAME)46) +#define FIT_SQUAT_EXERCISE_NAME_PISTOL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)47) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_PISTOL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)48) +#define FIT_SQUAT_EXERCISE_NAME_PLIE_SLIDES ((FIT_SQUAT_EXERCISE_NAME)49) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_PLIE_SLIDES ((FIT_SQUAT_EXERCISE_NAME)50) +#define FIT_SQUAT_EXERCISE_NAME_PLIE_SQUAT ((FIT_SQUAT_EXERCISE_NAME)51) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_PLIE_SQUAT ((FIT_SQUAT_EXERCISE_NAME)52) +#define FIT_SQUAT_EXERCISE_NAME_PRISONER_SQUAT ((FIT_SQUAT_EXERCISE_NAME)53) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_PRISONER_SQUAT ((FIT_SQUAT_EXERCISE_NAME)54) +#define FIT_SQUAT_EXERCISE_NAME_SINGLE_LEG_BENCH_GET_UP ((FIT_SQUAT_EXERCISE_NAME)55) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_BENCH_GET_UP ((FIT_SQUAT_EXERCISE_NAME)56) +#define FIT_SQUAT_EXERCISE_NAME_SINGLE_LEG_BENCH_SQUAT ((FIT_SQUAT_EXERCISE_NAME)57) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_BENCH_SQUAT ((FIT_SQUAT_EXERCISE_NAME)58) +#define FIT_SQUAT_EXERCISE_NAME_SINGLE_LEG_SQUAT_ON_SWISS_BALL ((FIT_SQUAT_EXERCISE_NAME)59) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_SQUAT_ON_SWISS_BALL ((FIT_SQUAT_EXERCISE_NAME)60) +#define FIT_SQUAT_EXERCISE_NAME_SQUAT ((FIT_SQUAT_EXERCISE_NAME)61) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SQUAT ((FIT_SQUAT_EXERCISE_NAME)62) +#define FIT_SQUAT_EXERCISE_NAME_SQUATS_WITH_BAND ((FIT_SQUAT_EXERCISE_NAME)63) +#define FIT_SQUAT_EXERCISE_NAME_STAGGERED_SQUAT ((FIT_SQUAT_EXERCISE_NAME)64) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_STAGGERED_SQUAT ((FIT_SQUAT_EXERCISE_NAME)65) +#define FIT_SQUAT_EXERCISE_NAME_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)66) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_STEP_UP ((FIT_SQUAT_EXERCISE_NAME)67) +#define FIT_SQUAT_EXERCISE_NAME_SUITCASE_SQUATS ((FIT_SQUAT_EXERCISE_NAME)68) +#define FIT_SQUAT_EXERCISE_NAME_SUMO_SQUAT ((FIT_SQUAT_EXERCISE_NAME)69) +#define FIT_SQUAT_EXERCISE_NAME_SUMO_SQUAT_SLIDE_IN ((FIT_SQUAT_EXERCISE_NAME)70) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SUMO_SQUAT_SLIDE_IN ((FIT_SQUAT_EXERCISE_NAME)71) +#define FIT_SQUAT_EXERCISE_NAME_SUMO_SQUAT_TO_HIGH_PULL ((FIT_SQUAT_EXERCISE_NAME)72) +#define FIT_SQUAT_EXERCISE_NAME_SUMO_SQUAT_TO_STAND ((FIT_SQUAT_EXERCISE_NAME)73) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SUMO_SQUAT_TO_STAND ((FIT_SQUAT_EXERCISE_NAME)74) +#define FIT_SQUAT_EXERCISE_NAME_SUMO_SQUAT_WITH_ROTATION ((FIT_SQUAT_EXERCISE_NAME)75) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SUMO_SQUAT_WITH_ROTATION ((FIT_SQUAT_EXERCISE_NAME)76) +#define FIT_SQUAT_EXERCISE_NAME_SWISS_BALL_BODY_WEIGHT_WALL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)77) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_SWISS_BALL_WALL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)78) +#define FIT_SQUAT_EXERCISE_NAME_THRUSTERS ((FIT_SQUAT_EXERCISE_NAME)79) +#define FIT_SQUAT_EXERCISE_NAME_UNEVEN_SQUAT ((FIT_SQUAT_EXERCISE_NAME)80) +#define FIT_SQUAT_EXERCISE_NAME_WEIGHTED_UNEVEN_SQUAT ((FIT_SQUAT_EXERCISE_NAME)81) +#define FIT_SQUAT_EXERCISE_NAME_WAIST_SLIMMING_SQUAT ((FIT_SQUAT_EXERCISE_NAME)82) +#define FIT_SQUAT_EXERCISE_NAME_WALL_BALL ((FIT_SQUAT_EXERCISE_NAME)83) +#define FIT_SQUAT_EXERCISE_NAME_WIDE_STANCE_BARBELL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)84) +#define FIT_SQUAT_EXERCISE_NAME_WIDE_STANCE_GOBLET_SQUAT ((FIT_SQUAT_EXERCISE_NAME)85) +#define FIT_SQUAT_EXERCISE_NAME_ZERCHER_SQUAT ((FIT_SQUAT_EXERCISE_NAME)86) +#define FIT_SQUAT_EXERCISE_NAME_KBS_OVERHEAD ((FIT_SQUAT_EXERCISE_NAME)87) // Deprecated do not use +#define FIT_SQUAT_EXERCISE_NAME_SQUAT_AND_SIDE_KICK ((FIT_SQUAT_EXERCISE_NAME)88) +#define FIT_SQUAT_EXERCISE_NAME_SQUAT_JUMPS_IN_N_OUT ((FIT_SQUAT_EXERCISE_NAME)89) +#define FIT_SQUAT_EXERCISE_NAME_PILATES_PLIE_SQUATS_PARALLEL_TURNED_OUT_FLAT_AND_HEELS ((FIT_SQUAT_EXERCISE_NAME)90) +#define FIT_SQUAT_EXERCISE_NAME_RELEVE_STRAIGHT_LEG_AND_KNEE_BENT_WITH_ONE_LEG_VARIATION ((FIT_SQUAT_EXERCISE_NAME)91) +#define FIT_SQUAT_EXERCISE_NAME_ALTERNATING_BOX_DUMBBELL_STEP_UPS ((FIT_SQUAT_EXERCISE_NAME)92) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_OVERHEAD_SQUAT_SINGLE_ARM ((FIT_SQUAT_EXERCISE_NAME)93) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_SQUAT_SNATCH ((FIT_SQUAT_EXERCISE_NAME)94) +#define FIT_SQUAT_EXERCISE_NAME_MEDICINE_BALL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)95) +#define FIT_SQUAT_EXERCISE_NAME_WALL_BALL_SQUAT_AND_PRESS ((FIT_SQUAT_EXERCISE_NAME)97) +#define FIT_SQUAT_EXERCISE_NAME_SQUAT_AMERICAN_SWING ((FIT_SQUAT_EXERCISE_NAME)98) +#define FIT_SQUAT_EXERCISE_NAME_AIR_SQUAT ((FIT_SQUAT_EXERCISE_NAME)100) +#define FIT_SQUAT_EXERCISE_NAME_DUMBBELL_THRUSTERS ((FIT_SQUAT_EXERCISE_NAME)101) +#define FIT_SQUAT_EXERCISE_NAME_OVERHEAD_BARBELL_SQUAT ((FIT_SQUAT_EXERCISE_NAME)102) +#define FIT_SQUAT_EXERCISE_NAME_COUNT 101 + +typedef FIT_UINT16 FIT_TOTAL_BODY_EXERCISE_NAME; +#define FIT_TOTAL_BODY_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_TOTAL_BODY_EXERCISE_NAME_BURPEE ((FIT_TOTAL_BODY_EXERCISE_NAME)0) +#define FIT_TOTAL_BODY_EXERCISE_NAME_WEIGHTED_BURPEE ((FIT_TOTAL_BODY_EXERCISE_NAME)1) +#define FIT_TOTAL_BODY_EXERCISE_NAME_BURPEE_BOX_JUMP ((FIT_TOTAL_BODY_EXERCISE_NAME)2) +#define FIT_TOTAL_BODY_EXERCISE_NAME_WEIGHTED_BURPEE_BOX_JUMP ((FIT_TOTAL_BODY_EXERCISE_NAME)3) +#define FIT_TOTAL_BODY_EXERCISE_NAME_HIGH_PULL_BURPEE ((FIT_TOTAL_BODY_EXERCISE_NAME)4) +#define FIT_TOTAL_BODY_EXERCISE_NAME_MAN_MAKERS ((FIT_TOTAL_BODY_EXERCISE_NAME)5) +#define FIT_TOTAL_BODY_EXERCISE_NAME_ONE_ARM_BURPEE ((FIT_TOTAL_BODY_EXERCISE_NAME)6) +#define FIT_TOTAL_BODY_EXERCISE_NAME_SQUAT_THRUSTS ((FIT_TOTAL_BODY_EXERCISE_NAME)7) +#define FIT_TOTAL_BODY_EXERCISE_NAME_WEIGHTED_SQUAT_THRUSTS ((FIT_TOTAL_BODY_EXERCISE_NAME)8) +#define FIT_TOTAL_BODY_EXERCISE_NAME_SQUAT_PLANK_PUSH_UP ((FIT_TOTAL_BODY_EXERCISE_NAME)9) +#define FIT_TOTAL_BODY_EXERCISE_NAME_WEIGHTED_SQUAT_PLANK_PUSH_UP ((FIT_TOTAL_BODY_EXERCISE_NAME)10) +#define FIT_TOTAL_BODY_EXERCISE_NAME_STANDING_T_ROTATION_BALANCE ((FIT_TOTAL_BODY_EXERCISE_NAME)11) +#define FIT_TOTAL_BODY_EXERCISE_NAME_WEIGHTED_STANDING_T_ROTATION_BALANCE ((FIT_TOTAL_BODY_EXERCISE_NAME)12) +#define FIT_TOTAL_BODY_EXERCISE_NAME_BARBELL_BURPEE ((FIT_TOTAL_BODY_EXERCISE_NAME)13) +#define FIT_TOTAL_BODY_EXERCISE_NAME_BURPEE_BOX_JUMP_OVER_YES_LITERALLY_JUMPING_OVER_THE_BOX ((FIT_TOTAL_BODY_EXERCISE_NAME)15) +#define FIT_TOTAL_BODY_EXERCISE_NAME_BURPEE_BOX_JUMP_STEP_UP_OVER ((FIT_TOTAL_BODY_EXERCISE_NAME)16) +#define FIT_TOTAL_BODY_EXERCISE_NAME_LATERAL_BARBELL_BURPEE ((FIT_TOTAL_BODY_EXERCISE_NAME)17) +#define FIT_TOTAL_BODY_EXERCISE_NAME_TOTAL_BODY_BURPEE_OVER_BAR ((FIT_TOTAL_BODY_EXERCISE_NAME)18) +#define FIT_TOTAL_BODY_EXERCISE_NAME_BURPEE_BOX_JUMP_OVER ((FIT_TOTAL_BODY_EXERCISE_NAME)19) +#define FIT_TOTAL_BODY_EXERCISE_NAME_BURPEE_WHEELCHAIR ((FIT_TOTAL_BODY_EXERCISE_NAME)20) +#define FIT_TOTAL_BODY_EXERCISE_NAME_COUNT 20 + +typedef FIT_UINT16 FIT_MOVE_EXERCISE_NAME; +#define FIT_MOVE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_MOVE_EXERCISE_NAME_ARCH_AND_CURL ((FIT_MOVE_EXERCISE_NAME)0) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_WITH_BALL_BAND_AND_WEIGHT ((FIT_MOVE_EXERCISE_NAME)1) +#define FIT_MOVE_EXERCISE_NAME_ARM_STRETCH ((FIT_MOVE_EXERCISE_NAME)2) +#define FIT_MOVE_EXERCISE_NAME_BACK_MASSAGE ((FIT_MOVE_EXERCISE_NAME)3) +#define FIT_MOVE_EXERCISE_NAME_BELLY_BREATHING ((FIT_MOVE_EXERCISE_NAME)4) +#define FIT_MOVE_EXERCISE_NAME_BRIDGE_WITH_BALL ((FIT_MOVE_EXERCISE_NAME)5) +#define FIT_MOVE_EXERCISE_NAME_DIAMOND_LEG_CRUNCH ((FIT_MOVE_EXERCISE_NAME)6) +#define FIT_MOVE_EXERCISE_NAME_DIAMOND_LEG_LIFT ((FIT_MOVE_EXERCISE_NAME)7) +#define FIT_MOVE_EXERCISE_NAME_EIGHT_POINT_SHOULDER_OPENER ((FIT_MOVE_EXERCISE_NAME)8) +#define FIT_MOVE_EXERCISE_NAME_FOOT_ROLLING ((FIT_MOVE_EXERCISE_NAME)9) +#define FIT_MOVE_EXERCISE_NAME_FOOTWORK ((FIT_MOVE_EXERCISE_NAME)10) +#define FIT_MOVE_EXERCISE_NAME_FOOTWORK_ON_DISC ((FIT_MOVE_EXERCISE_NAME)11) +#define FIT_MOVE_EXERCISE_NAME_FORWARD_FOLD ((FIT_MOVE_EXERCISE_NAME)12) +#define FIT_MOVE_EXERCISE_NAME_FROG_WITH_BAND ((FIT_MOVE_EXERCISE_NAME)13) +#define FIT_MOVE_EXERCISE_NAME_HALF_ROLL_UP ((FIT_MOVE_EXERCISE_NAME)14) +#define FIT_MOVE_EXERCISE_NAME_HAMSTRING_CURL ((FIT_MOVE_EXERCISE_NAME)15) +#define FIT_MOVE_EXERCISE_NAME_HAMSTRING_STRETCH ((FIT_MOVE_EXERCISE_NAME)16) +#define FIT_MOVE_EXERCISE_NAME_HIP_STRETCH ((FIT_MOVE_EXERCISE_NAME)17) +#define FIT_MOVE_EXERCISE_NAME_HUG_A_TREE_WITH_BALL_BAND_AND_WEIGHT ((FIT_MOVE_EXERCISE_NAME)18) +#define FIT_MOVE_EXERCISE_NAME_KNEE_CIRCLES ((FIT_MOVE_EXERCISE_NAME)19) +#define FIT_MOVE_EXERCISE_NAME_KNEE_FOLDS_ON_DISC ((FIT_MOVE_EXERCISE_NAME)20) +#define FIT_MOVE_EXERCISE_NAME_LATERAL_FLEXION ((FIT_MOVE_EXERCISE_NAME)21) +#define FIT_MOVE_EXERCISE_NAME_LEG_STRETCH_WITH_BAND ((FIT_MOVE_EXERCISE_NAME)22) +#define FIT_MOVE_EXERCISE_NAME_LEG_STRETCH_WITH_LEG_CIRCLES ((FIT_MOVE_EXERCISE_NAME)23) +#define FIT_MOVE_EXERCISE_NAME_LOWER_LIFT_ON_DISC ((FIT_MOVE_EXERCISE_NAME)24) +#define FIT_MOVE_EXERCISE_NAME_LUNGE_SQUAT ((FIT_MOVE_EXERCISE_NAME)25) +#define FIT_MOVE_EXERCISE_NAME_LUNGES_WITH_KNEE_LIFT ((FIT_MOVE_EXERCISE_NAME)26) +#define FIT_MOVE_EXERCISE_NAME_MERMAID_STRETCH ((FIT_MOVE_EXERCISE_NAME)27) +#define FIT_MOVE_EXERCISE_NAME_NEUTRAL_PELVIC_POSITION ((FIT_MOVE_EXERCISE_NAME)28) +#define FIT_MOVE_EXERCISE_NAME_PELVIC_CLOCKS_ON_DISC ((FIT_MOVE_EXERCISE_NAME)29) +#define FIT_MOVE_EXERCISE_NAME_PILATES_PLIE_SQUATS_PARALLEL_TURNED_OUT_FLAT_AND_HEELS_WITH_CHAIR ((FIT_MOVE_EXERCISE_NAME)30) +#define FIT_MOVE_EXERCISE_NAME_PIRIFORMIS_STRETCH ((FIT_MOVE_EXERCISE_NAME)31) +#define FIT_MOVE_EXERCISE_NAME_PLANK_KNEE_CROSSES ((FIT_MOVE_EXERCISE_NAME)32) +#define FIT_MOVE_EXERCISE_NAME_PLANK_KNEE_PULLS ((FIT_MOVE_EXERCISE_NAME)33) +#define FIT_MOVE_EXERCISE_NAME_PLANK_UP_DOWNS ((FIT_MOVE_EXERCISE_NAME)34) +#define FIT_MOVE_EXERCISE_NAME_PRAYER_MUDRA ((FIT_MOVE_EXERCISE_NAME)35) +#define FIT_MOVE_EXERCISE_NAME_PSOAS_LUNGE_STRETCH ((FIT_MOVE_EXERCISE_NAME)36) +#define FIT_MOVE_EXERCISE_NAME_RIBCAGE_BREATHING ((FIT_MOVE_EXERCISE_NAME)37) +#define FIT_MOVE_EXERCISE_NAME_ROLL_DOWN ((FIT_MOVE_EXERCISE_NAME)38) +#define FIT_MOVE_EXERCISE_NAME_ROLL_UP_WITH_WEIGHT_AND_BAND ((FIT_MOVE_EXERCISE_NAME)39) +#define FIT_MOVE_EXERCISE_NAME_SAW ((FIT_MOVE_EXERCISE_NAME)40) +#define FIT_MOVE_EXERCISE_NAME_SCAPULAR_STABILIZATION ((FIT_MOVE_EXERCISE_NAME)41) +#define FIT_MOVE_EXERCISE_NAME_SCISSORS_ON_DISC ((FIT_MOVE_EXERCISE_NAME)42) +#define FIT_MOVE_EXERCISE_NAME_SEATED_HIP_STRETCHUP ((FIT_MOVE_EXERCISE_NAME)43) +#define FIT_MOVE_EXERCISE_NAME_SEATED_TWIST ((FIT_MOVE_EXERCISE_NAME)44) +#define FIT_MOVE_EXERCISE_NAME_SHAVING_THE_HEAD_WITH_BALL_BAND_AND_WEIGHT ((FIT_MOVE_EXERCISE_NAME)45) +#define FIT_MOVE_EXERCISE_NAME_SPINAL_TWIST ((FIT_MOVE_EXERCISE_NAME)46) +#define FIT_MOVE_EXERCISE_NAME_SPINAL_TWIST_STRETCH ((FIT_MOVE_EXERCISE_NAME)47) +#define FIT_MOVE_EXERCISE_NAME_SPINE_STRETCH_FORWARD ((FIT_MOVE_EXERCISE_NAME)48) +#define FIT_MOVE_EXERCISE_NAME_SQUAT_OPEN_ARM_TWIST_POSE ((FIT_MOVE_EXERCISE_NAME)49) +#define FIT_MOVE_EXERCISE_NAME_SQUATS_WITH_BALL ((FIT_MOVE_EXERCISE_NAME)50) +#define FIT_MOVE_EXERCISE_NAME_STAND_AND_HANG ((FIT_MOVE_EXERCISE_NAME)51) +#define FIT_MOVE_EXERCISE_NAME_STANDING_SIDE_STRETCH ((FIT_MOVE_EXERCISE_NAME)52) +#define FIT_MOVE_EXERCISE_NAME_STANDING_SINGLE_LEG_FORWARD_BEND_WITH_IT_BAND_OPENER ((FIT_MOVE_EXERCISE_NAME)53) +#define FIT_MOVE_EXERCISE_NAME_STRAIGHT_LEG_CRUNCH_WITH_LEG_LIFT ((FIT_MOVE_EXERCISE_NAME)54) +#define FIT_MOVE_EXERCISE_NAME_STRAIGHT_LEG_CRUNCH_WITH_LEG_LIFT_WITH_BALL ((FIT_MOVE_EXERCISE_NAME)55) +#define FIT_MOVE_EXERCISE_NAME_STRAIGHT_LEG_CRUNCH_WITH_LEGS_CROSSED ((FIT_MOVE_EXERCISE_NAME)56) +#define FIT_MOVE_EXERCISE_NAME_STRAIGHT_LEG_CRUNCH_WITH_LEGS_CROSSED_WITH_BALL ((FIT_MOVE_EXERCISE_NAME)57) +#define FIT_MOVE_EXERCISE_NAME_STRAIGHT_LEG_DIAGONAL_CRUNCH ((FIT_MOVE_EXERCISE_NAME)58) +#define FIT_MOVE_EXERCISE_NAME_STRAIGHT_LEG_DIAGONAL_CRUNCH_WITH_BALL ((FIT_MOVE_EXERCISE_NAME)59) +#define FIT_MOVE_EXERCISE_NAME_TAILBONE_CURL ((FIT_MOVE_EXERCISE_NAME)60) +#define FIT_MOVE_EXERCISE_NAME_THROAT_LOCK ((FIT_MOVE_EXERCISE_NAME)61) +#define FIT_MOVE_EXERCISE_NAME_TICK_TOCK_SIDE_ROLL ((FIT_MOVE_EXERCISE_NAME)62) +#define FIT_MOVE_EXERCISE_NAME_TWIST ((FIT_MOVE_EXERCISE_NAME)63) +#define FIT_MOVE_EXERCISE_NAME_V_LEG_CRUNCHES ((FIT_MOVE_EXERCISE_NAME)64) +#define FIT_MOVE_EXERCISE_NAME_V_SIT ((FIT_MOVE_EXERCISE_NAME)65) +#define FIT_MOVE_EXERCISE_NAME_FORWARD_FOLD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)66) +#define FIT_MOVE_EXERCISE_NAME_FORWARD_FOLD_PLUS_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)67) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_LOW_FORWARD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)68) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_MID_FORWARD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)69) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_HIGH_FORWARD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)70) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_LOW_BACKWARD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)71) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_MID_BACKWARD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)72) +#define FIT_MOVE_EXERCISE_NAME_ARM_CIRCLES_HIGH_BACKWARD_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)73) +#define FIT_MOVE_EXERCISE_NAME_CORE_TWISTS_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)74) +#define FIT_MOVE_EXERCISE_NAME_ARM_RAISE_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)75) +#define FIT_MOVE_EXERCISE_NAME_CHEST_EXPAND_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)76) +#define FIT_MOVE_EXERCISE_NAME_ARM_EXTEND_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)77) +#define FIT_MOVE_EXERCISE_NAME_FORWARD_BEND_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)78) +#define FIT_MOVE_EXERCISE_NAME_TOE_TOUCH_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)79) +#define FIT_MOVE_EXERCISE_NAME_EXTENDED_TOE_TOUCH_WHEELCHAIR ((FIT_MOVE_EXERCISE_NAME)80) +#define FIT_MOVE_EXERCISE_NAME_SEATED_ARM_CIRCLES ((FIT_MOVE_EXERCISE_NAME)81) +#define FIT_MOVE_EXERCISE_NAME_TRUNK_ROTATIONS ((FIT_MOVE_EXERCISE_NAME)82) +#define FIT_MOVE_EXERCISE_NAME_SEATED_TRUNK_ROTATIONS ((FIT_MOVE_EXERCISE_NAME)83) +#define FIT_MOVE_EXERCISE_NAME_TOE_TOUCH ((FIT_MOVE_EXERCISE_NAME)84) +#define FIT_MOVE_EXERCISE_NAME_COUNT 85 + +typedef FIT_UINT16 FIT_POSE_EXERCISE_NAME; +#define FIT_POSE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_POSE_EXERCISE_NAME_ALL_FOURS ((FIT_POSE_EXERCISE_NAME)0) +#define FIT_POSE_EXERCISE_NAME_ANKLE_TO_KNEE ((FIT_POSE_EXERCISE_NAME)1) +#define FIT_POSE_EXERCISE_NAME_BABY_COBRA ((FIT_POSE_EXERCISE_NAME)2) +#define FIT_POSE_EXERCISE_NAME_BOAT ((FIT_POSE_EXERCISE_NAME)3) +#define FIT_POSE_EXERCISE_NAME_BOUND_ANGLE ((FIT_POSE_EXERCISE_NAME)4) +#define FIT_POSE_EXERCISE_NAME_BOUND_SEATED_SINGLE_LEG_FORWARD_BEND ((FIT_POSE_EXERCISE_NAME)5) +#define FIT_POSE_EXERCISE_NAME_BOW ((FIT_POSE_EXERCISE_NAME)6) +#define FIT_POSE_EXERCISE_NAME_BOWED_HALF_MOON ((FIT_POSE_EXERCISE_NAME)7) +#define FIT_POSE_EXERCISE_NAME_BRIDGE ((FIT_POSE_EXERCISE_NAME)8) +#define FIT_POSE_EXERCISE_NAME_CAT ((FIT_POSE_EXERCISE_NAME)9) +#define FIT_POSE_EXERCISE_NAME_CHAIR ((FIT_POSE_EXERCISE_NAME)10) +#define FIT_POSE_EXERCISE_NAME_CHILDS ((FIT_POSE_EXERCISE_NAME)11) +#define FIT_POSE_EXERCISE_NAME_CORPSE ((FIT_POSE_EXERCISE_NAME)12) +#define FIT_POSE_EXERCISE_NAME_COW_FACE ((FIT_POSE_EXERCISE_NAME)13) +#define FIT_POSE_EXERCISE_NAME_COW ((FIT_POSE_EXERCISE_NAME)14) +#define FIT_POSE_EXERCISE_NAME_DEVOTIONAL_WARRIOR ((FIT_POSE_EXERCISE_NAME)15) +#define FIT_POSE_EXERCISE_NAME_DOLPHIN_PLANK ((FIT_POSE_EXERCISE_NAME)16) +#define FIT_POSE_EXERCISE_NAME_DOLPHIN ((FIT_POSE_EXERCISE_NAME)17) +#define FIT_POSE_EXERCISE_NAME_DOWN_DOG_KNEE_TO_NOSE ((FIT_POSE_EXERCISE_NAME)18) +#define FIT_POSE_EXERCISE_NAME_DOWN_DOG_SPLIT ((FIT_POSE_EXERCISE_NAME)19) +#define FIT_POSE_EXERCISE_NAME_DOWN_DOG_SPLIT_OPEN_HIP_BENT_KNEE ((FIT_POSE_EXERCISE_NAME)20) +#define FIT_POSE_EXERCISE_NAME_DOWNWARD_FACING_DOG ((FIT_POSE_EXERCISE_NAME)21) +#define FIT_POSE_EXERCISE_NAME_EAGLE ((FIT_POSE_EXERCISE_NAME)22) +#define FIT_POSE_EXERCISE_NAME_EASY_SEATED ((FIT_POSE_EXERCISE_NAME)23) +#define FIT_POSE_EXERCISE_NAME_EXTENDED_PUPPY ((FIT_POSE_EXERCISE_NAME)24) +#define FIT_POSE_EXERCISE_NAME_EXTENDED_SIDE_ANGLE ((FIT_POSE_EXERCISE_NAME)25) +#define FIT_POSE_EXERCISE_NAME_FISH ((FIT_POSE_EXERCISE_NAME)26) +#define FIT_POSE_EXERCISE_NAME_FOUR_LIMBED_STAFF ((FIT_POSE_EXERCISE_NAME)27) +#define FIT_POSE_EXERCISE_NAME_FULL_SPLIT ((FIT_POSE_EXERCISE_NAME)28) +#define FIT_POSE_EXERCISE_NAME_GATE ((FIT_POSE_EXERCISE_NAME)29) +#define FIT_POSE_EXERCISE_NAME_HALF_CHAIR_HALF_ANKLE_TO_KNEE ((FIT_POSE_EXERCISE_NAME)30) +#define FIT_POSE_EXERCISE_NAME_HALF_MOON ((FIT_POSE_EXERCISE_NAME)31) +#define FIT_POSE_EXERCISE_NAME_HEAD_TO_KNEE ((FIT_POSE_EXERCISE_NAME)32) +#define FIT_POSE_EXERCISE_NAME_HERON ((FIT_POSE_EXERCISE_NAME)33) +#define FIT_POSE_EXERCISE_NAME_HEROS ((FIT_POSE_EXERCISE_NAME)34) +#define FIT_POSE_EXERCISE_NAME_HIGH_LUNGE ((FIT_POSE_EXERCISE_NAME)35) +#define FIT_POSE_EXERCISE_NAME_KNEES_CHEST_CHIN ((FIT_POSE_EXERCISE_NAME)36) +#define FIT_POSE_EXERCISE_NAME_LIZARD ((FIT_POSE_EXERCISE_NAME)37) +#define FIT_POSE_EXERCISE_NAME_LOCUST ((FIT_POSE_EXERCISE_NAME)38) +#define FIT_POSE_EXERCISE_NAME_LOW_LUNGE ((FIT_POSE_EXERCISE_NAME)39) +#define FIT_POSE_EXERCISE_NAME_LOW_LUNGE_TWIST ((FIT_POSE_EXERCISE_NAME)40) +#define FIT_POSE_EXERCISE_NAME_LOW_LUNGE_WITH_KNEE_DOWN ((FIT_POSE_EXERCISE_NAME)41) +#define FIT_POSE_EXERCISE_NAME_MERMAID ((FIT_POSE_EXERCISE_NAME)42) +#define FIT_POSE_EXERCISE_NAME_MOUNTAIN ((FIT_POSE_EXERCISE_NAME)43) +#define FIT_POSE_EXERCISE_NAME_ONE_LEGGED_DOWNWARD_FACING_POSE_OPEN_HIP_BENT_KNEE ((FIT_POSE_EXERCISE_NAME)44) +#define FIT_POSE_EXERCISE_NAME_ONE_LEGGED_PIGEON ((FIT_POSE_EXERCISE_NAME)45) +#define FIT_POSE_EXERCISE_NAME_PEACEFUL_WARRIOR ((FIT_POSE_EXERCISE_NAME)46) +#define FIT_POSE_EXERCISE_NAME_PLANK ((FIT_POSE_EXERCISE_NAME)47) +#define FIT_POSE_EXERCISE_NAME_PLOW ((FIT_POSE_EXERCISE_NAME)48) +#define FIT_POSE_EXERCISE_NAME_RECLINED_HAND_TO_FOOT ((FIT_POSE_EXERCISE_NAME)49) +#define FIT_POSE_EXERCISE_NAME_REVOLVED_HALF_MOON ((FIT_POSE_EXERCISE_NAME)50) +#define FIT_POSE_EXERCISE_NAME_REVOLVED_HEAD_TO_KNEE ((FIT_POSE_EXERCISE_NAME)51) +#define FIT_POSE_EXERCISE_NAME_REVOLVED_TRIANGLE ((FIT_POSE_EXERCISE_NAME)52) +#define FIT_POSE_EXERCISE_NAME_RUNNERS_LUNGE ((FIT_POSE_EXERCISE_NAME)53) +#define FIT_POSE_EXERCISE_NAME_SEATED_EASY_SIDE_BEND ((FIT_POSE_EXERCISE_NAME)54) +#define FIT_POSE_EXERCISE_NAME_SEATED_EASY_TWIST ((FIT_POSE_EXERCISE_NAME)55) +#define FIT_POSE_EXERCISE_NAME_SEATED_LONG_LEG_FORWARD_BEND ((FIT_POSE_EXERCISE_NAME)56) +#define FIT_POSE_EXERCISE_NAME_SEATED_WIDE_LEG_FORWARD_BEND ((FIT_POSE_EXERCISE_NAME)57) +#define FIT_POSE_EXERCISE_NAME_SHOULDER_STAND ((FIT_POSE_EXERCISE_NAME)58) +#define FIT_POSE_EXERCISE_NAME_SIDE_BOAT ((FIT_POSE_EXERCISE_NAME)59) +#define FIT_POSE_EXERCISE_NAME_SIDE_PLANK ((FIT_POSE_EXERCISE_NAME)60) +#define FIT_POSE_EXERCISE_NAME_SPHINX ((FIT_POSE_EXERCISE_NAME)61) +#define FIT_POSE_EXERCISE_NAME_SQUAT_OPEN_ARM_TWIST ((FIT_POSE_EXERCISE_NAME)62) +#define FIT_POSE_EXERCISE_NAME_SQUAT_PALM_PRESS ((FIT_POSE_EXERCISE_NAME)63) +#define FIT_POSE_EXERCISE_NAME_STAFF ((FIT_POSE_EXERCISE_NAME)64) +#define FIT_POSE_EXERCISE_NAME_STANDING_ARMS_UP ((FIT_POSE_EXERCISE_NAME)65) +#define FIT_POSE_EXERCISE_NAME_STANDING_FORWARD_BEND_HALFWAY_UP ((FIT_POSE_EXERCISE_NAME)66) +#define FIT_POSE_EXERCISE_NAME_STANDING_FORWARD_BEND ((FIT_POSE_EXERCISE_NAME)67) +#define FIT_POSE_EXERCISE_NAME_STANDING_SIDE_OPENER ((FIT_POSE_EXERCISE_NAME)68) +#define FIT_POSE_EXERCISE_NAME_STANDING_SINGLE_LEG_FORWARD_BEND ((FIT_POSE_EXERCISE_NAME)69) +#define FIT_POSE_EXERCISE_NAME_STANDING_SPLIT ((FIT_POSE_EXERCISE_NAME)70) +#define FIT_POSE_EXERCISE_NAME_STANDING_WIDE_LEG_FORWARD_BEND ((FIT_POSE_EXERCISE_NAME)71) +#define FIT_POSE_EXERCISE_NAME_STANDING_WIDE_LEG_FORWARD_BEND_WITH_TWIST ((FIT_POSE_EXERCISE_NAME)72) +#define FIT_POSE_EXERCISE_NAME_SUPINE_SPINAL_TWIST ((FIT_POSE_EXERCISE_NAME)73) +#define FIT_POSE_EXERCISE_NAME_TABLE_TOP ((FIT_POSE_EXERCISE_NAME)74) +#define FIT_POSE_EXERCISE_NAME_THREAD_THE_NEEDLE ((FIT_POSE_EXERCISE_NAME)75) +#define FIT_POSE_EXERCISE_NAME_THUNDERBOLT ((FIT_POSE_EXERCISE_NAME)76) +#define FIT_POSE_EXERCISE_NAME_THUNDERBOLT_POSE_BOTH_SIDES_ARM_STRETCH ((FIT_POSE_EXERCISE_NAME)77) +#define FIT_POSE_EXERCISE_NAME_TREE ((FIT_POSE_EXERCISE_NAME)78) +#define FIT_POSE_EXERCISE_NAME_TRIANGLE ((FIT_POSE_EXERCISE_NAME)79) +#define FIT_POSE_EXERCISE_NAME_UP_DOG ((FIT_POSE_EXERCISE_NAME)80) +#define FIT_POSE_EXERCISE_NAME_UPWARD_FACING_PLANK ((FIT_POSE_EXERCISE_NAME)81) +#define FIT_POSE_EXERCISE_NAME_WARRIOR_ONE ((FIT_POSE_EXERCISE_NAME)82) +#define FIT_POSE_EXERCISE_NAME_WARRIOR_THREE ((FIT_POSE_EXERCISE_NAME)83) +#define FIT_POSE_EXERCISE_NAME_WARRIOR_TWO ((FIT_POSE_EXERCISE_NAME)84) +#define FIT_POSE_EXERCISE_NAME_WHEEL ((FIT_POSE_EXERCISE_NAME)85) +#define FIT_POSE_EXERCISE_NAME_WIDE_SIDE_LUNGE ((FIT_POSE_EXERCISE_NAME)86) +#define FIT_POSE_EXERCISE_NAME_DEEP_BREATHING_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)87) +#define FIT_POSE_EXERCISE_NAME_DEEP_BREATHING_LOW_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)88) +#define FIT_POSE_EXERCISE_NAME_DEEP_BREATHING_MID_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)89) +#define FIT_POSE_EXERCISE_NAME_DEEP_BREATHING_HIGH_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)90) +#define FIT_POSE_EXERCISE_NAME_PRAYER_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)91) +#define FIT_POSE_EXERCISE_NAME_OVERHEAD_PRAYER_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)92) +#define FIT_POSE_EXERCISE_NAME_CACTUS_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)93) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)94) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_EXTENDED_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)95) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_OVERHEAD_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)96) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_OVERHEAD_AND_DOWN_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)97) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_SIDE_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)98) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_EXTENDED_SIDE_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)99) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_OVERHEAD_SIDE_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)100) +#define FIT_POSE_EXERCISE_NAME_BREATHING_PUNCHES_OVERHEAD_AND_DOWN_SIDE_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)101) +#define FIT_POSE_EXERCISE_NAME_LEFT_HAND_BACK_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)102) +#define FIT_POSE_EXERCISE_NAME_TRIANGLE_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)103) +#define FIT_POSE_EXERCISE_NAME_THREAD_THE_NEEDLE_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)104) +#define FIT_POSE_EXERCISE_NAME_NECK_FLEXION_AND_EXTENSION_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)105) +#define FIT_POSE_EXERCISE_NAME_NECK_LATERAL_FLEXION_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)106) +#define FIT_POSE_EXERCISE_NAME_SPINE_FLEXION_AND_EXTENSION_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)107) +#define FIT_POSE_EXERCISE_NAME_SPINE_ROTATION_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)108) +#define FIT_POSE_EXERCISE_NAME_SPINE_LATERAL_FLEXION_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)109) +#define FIT_POSE_EXERCISE_NAME_ALTERNATIVE_SKIING_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)110) +#define FIT_POSE_EXERCISE_NAME_REACH_FORWARD_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)111) +#define FIT_POSE_EXERCISE_NAME_WARRIOR_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)112) +#define FIT_POSE_EXERCISE_NAME_REVERSE_WARRIOR_WHEELCHAIR ((FIT_POSE_EXERCISE_NAME)113) +#define FIT_POSE_EXERCISE_NAME_DOWNWARD_FACING_DOG_TO_COBRA ((FIT_POSE_EXERCISE_NAME)114) +#define FIT_POSE_EXERCISE_NAME_SEATED_CAT_COW ((FIT_POSE_EXERCISE_NAME)115) +#define FIT_POSE_EXERCISE_NAME_COUNT 116 + +typedef FIT_UINT16 FIT_TRICEPS_EXTENSION_EXERCISE_NAME; +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_BENCH_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)0) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_BENCH_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)1) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_BODY_WEIGHT_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)2) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_CABLE_KICKBACK ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)3) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_CABLE_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)4) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_CABLE_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)5) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_DUMBBELL_KICKBACK ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)6) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_DUMBBELL_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)7) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_EZ_BAR_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)8) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_INCLINE_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)9) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_INCLINE_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)10) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_INCLINE_EZ_BAR_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)11) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_LYING_DUMBBELL_PULLOVER_TO_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)12) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_LYING_EZ_BAR_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)13) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_LYING_TRICEPS_EXTENSION_TO_CLOSE_GRIP_BENCH_PRESS ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)14) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_OVERHEAD_DUMBBELL_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)15) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_RECLINING_TRICEPS_PRESS ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)16) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_REVERSE_GRIP_PRESSDOWN ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)17) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_REVERSE_GRIP_TRICEPS_PRESSDOWN ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)18) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_ROPE_PRESSDOWN ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)19) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SEATED_BARBELL_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)20) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SEATED_DUMBBELL_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)21) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SEATED_EZ_BAR_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)22) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SEATED_SINGLE_ARM_OVERHEAD_DUMBBELL_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)23) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SINGLE_ARM_DUMBBELL_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)24) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SINGLE_DUMBBELL_SEATED_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)25) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SINGLE_LEG_BENCH_DIP_AND_KICK ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)26) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_BENCH_DIP_AND_KICK ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)27) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SINGLE_LEG_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)28) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_SINGLE_LEG_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)29) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_STATIC_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)30) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SUSPENDED_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)31) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_SUSPENDED_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)32) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SWISS_BALL_DUMBBELL_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)33) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SWISS_BALL_EZ_BAR_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)34) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_SWISS_BALL_EZ_BAR_OVERHEAD_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)35) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_TABLETOP_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)36) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_TABLETOP_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)37) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_TRICEPS_EXTENSION_ON_FLOOR ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)38) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_TRICEPS_PRESSDOWN ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)39) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_WEIGHTED_DIP ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)40) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_ALTERNATING_DUMBBELL_LYING_TRICEPS_EXTENSION ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)41) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_TRICEPS_PRESS ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)42) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_DUMBBELL_KICKBACK_WHEELCHAIR ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)43) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_OVERHEAD_DUMBBELL_TRICEPS_EXTENSION_WHEELCHAIR ((FIT_TRICEPS_EXTENSION_EXERCISE_NAME)44) +#define FIT_TRICEPS_EXTENSION_EXERCISE_NAME_COUNT 45 + +typedef FIT_UINT16 FIT_WARM_UP_EXERCISE_NAME; +#define FIT_WARM_UP_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_WARM_UP_EXERCISE_NAME_QUADRUPED_ROCKING ((FIT_WARM_UP_EXERCISE_NAME)0) +#define FIT_WARM_UP_EXERCISE_NAME_NECK_TILTS ((FIT_WARM_UP_EXERCISE_NAME)1) +#define FIT_WARM_UP_EXERCISE_NAME_ANKLE_CIRCLES ((FIT_WARM_UP_EXERCISE_NAME)2) +#define FIT_WARM_UP_EXERCISE_NAME_ANKLE_DORSIFLEXION_WITH_BAND ((FIT_WARM_UP_EXERCISE_NAME)3) +#define FIT_WARM_UP_EXERCISE_NAME_ANKLE_INTERNAL_ROTATION ((FIT_WARM_UP_EXERCISE_NAME)4) +#define FIT_WARM_UP_EXERCISE_NAME_ARM_CIRCLES ((FIT_WARM_UP_EXERCISE_NAME)5) +#define FIT_WARM_UP_EXERCISE_NAME_BENT_OVER_REACH_TO_SKY ((FIT_WARM_UP_EXERCISE_NAME)6) +#define FIT_WARM_UP_EXERCISE_NAME_CAT_CAMEL ((FIT_WARM_UP_EXERCISE_NAME)7) +#define FIT_WARM_UP_EXERCISE_NAME_ELBOW_TO_FOOT_LUNGE ((FIT_WARM_UP_EXERCISE_NAME)8) +#define FIT_WARM_UP_EXERCISE_NAME_FORWARD_AND_BACKWARD_LEG_SWINGS ((FIT_WARM_UP_EXERCISE_NAME)9) +#define FIT_WARM_UP_EXERCISE_NAME_GROINERS ((FIT_WARM_UP_EXERCISE_NAME)10) +#define FIT_WARM_UP_EXERCISE_NAME_INVERTED_HAMSTRING_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)11) +#define FIT_WARM_UP_EXERCISE_NAME_LATERAL_DUCK_UNDER ((FIT_WARM_UP_EXERCISE_NAME)12) +#define FIT_WARM_UP_EXERCISE_NAME_NECK_ROTATIONS ((FIT_WARM_UP_EXERCISE_NAME)13) +#define FIT_WARM_UP_EXERCISE_NAME_OPPOSITE_ARM_AND_LEG_BALANCE ((FIT_WARM_UP_EXERCISE_NAME)14) +#define FIT_WARM_UP_EXERCISE_NAME_REACH_ROLL_AND_LIFT ((FIT_WARM_UP_EXERCISE_NAME)15) +#define FIT_WARM_UP_EXERCISE_NAME_SCORPION ((FIT_WARM_UP_EXERCISE_NAME)16) // Deprecated do not use +#define FIT_WARM_UP_EXERCISE_NAME_SHOULDER_CIRCLES ((FIT_WARM_UP_EXERCISE_NAME)17) +#define FIT_WARM_UP_EXERCISE_NAME_SIDE_TO_SIDE_LEG_SWINGS ((FIT_WARM_UP_EXERCISE_NAME)18) +#define FIT_WARM_UP_EXERCISE_NAME_SLEEPER_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)19) +#define FIT_WARM_UP_EXERCISE_NAME_SLIDE_OUT ((FIT_WARM_UP_EXERCISE_NAME)20) +#define FIT_WARM_UP_EXERCISE_NAME_SWISS_BALL_HIP_CROSSOVER ((FIT_WARM_UP_EXERCISE_NAME)21) +#define FIT_WARM_UP_EXERCISE_NAME_SWISS_BALL_REACH_ROLL_AND_LIFT ((FIT_WARM_UP_EXERCISE_NAME)22) +#define FIT_WARM_UP_EXERCISE_NAME_SWISS_BALL_WINDSHIELD_WIPERS ((FIT_WARM_UP_EXERCISE_NAME)23) +#define FIT_WARM_UP_EXERCISE_NAME_THORACIC_ROTATION ((FIT_WARM_UP_EXERCISE_NAME)24) +#define FIT_WARM_UP_EXERCISE_NAME_WALKING_HIGH_KICKS ((FIT_WARM_UP_EXERCISE_NAME)25) +#define FIT_WARM_UP_EXERCISE_NAME_WALKING_HIGH_KNEES ((FIT_WARM_UP_EXERCISE_NAME)26) +#define FIT_WARM_UP_EXERCISE_NAME_WALKING_KNEE_HUGS ((FIT_WARM_UP_EXERCISE_NAME)27) +#define FIT_WARM_UP_EXERCISE_NAME_WALKING_LEG_CRADLES ((FIT_WARM_UP_EXERCISE_NAME)28) +#define FIT_WARM_UP_EXERCISE_NAME_WALKOUT ((FIT_WARM_UP_EXERCISE_NAME)29) +#define FIT_WARM_UP_EXERCISE_NAME_WALKOUT_FROM_PUSH_UP_POSITION ((FIT_WARM_UP_EXERCISE_NAME)30) +#define FIT_WARM_UP_EXERCISE_NAME_BICEPS_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)31) +#define FIT_WARM_UP_EXERCISE_NAME_GLUTES_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)32) +#define FIT_WARM_UP_EXERCISE_NAME_STANDING_HAMSTRING_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)33) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_90_90 ((FIT_WARM_UP_EXERCISE_NAME)34) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_ABS ((FIT_WARM_UP_EXERCISE_NAME)35) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_BUTTERFLY ((FIT_WARM_UP_EXERCISE_NAME)36) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_CALF ((FIT_WARM_UP_EXERCISE_NAME)37) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_CAT_COW ((FIT_WARM_UP_EXERCISE_NAME)38) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_CHILDS_POSE ((FIT_WARM_UP_EXERCISE_NAME)39) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_COBRA ((FIT_WARM_UP_EXERCISE_NAME)40) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_FOREARMS ((FIT_WARM_UP_EXERCISE_NAME)41) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_FORWARD_GLUTES ((FIT_WARM_UP_EXERCISE_NAME)42) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_FRONT_SPLIT ((FIT_WARM_UP_EXERCISE_NAME)43) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_HAMSTRING ((FIT_WARM_UP_EXERCISE_NAME)44) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_HIP_FLEXOR_AND_QUAD ((FIT_WARM_UP_EXERCISE_NAME)45) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LAT ((FIT_WARM_UP_EXERCISE_NAME)46) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LEVATOR_SCAPULAE ((FIT_WARM_UP_EXERCISE_NAME)47) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LUNGE_WITH_SPINAL_TWIST ((FIT_WARM_UP_EXERCISE_NAME)48) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LUNGING_HIP_FLEXOR ((FIT_WARM_UP_EXERCISE_NAME)49) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LYING_ABDUCTION ((FIT_WARM_UP_EXERCISE_NAME)50) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LYING_IT_BAND ((FIT_WARM_UP_EXERCISE_NAME)51) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LYING_KNEE_TO_CHEST ((FIT_WARM_UP_EXERCISE_NAME)52) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LYING_PIRIFORMIS ((FIT_WARM_UP_EXERCISE_NAME)53) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_LYING_SPINAL_TWIST ((FIT_WARM_UP_EXERCISE_NAME)54) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_NECK ((FIT_WARM_UP_EXERCISE_NAME)55) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_OBLIQUES ((FIT_WARM_UP_EXERCISE_NAME)56) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_OVER_UNDER_SHOULDER ((FIT_WARM_UP_EXERCISE_NAME)57) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_PECTORAL ((FIT_WARM_UP_EXERCISE_NAME)58) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_PIGEON_POSE ((FIT_WARM_UP_EXERCISE_NAME)59) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_PIRIFORMIS ((FIT_WARM_UP_EXERCISE_NAME)60) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_QUAD ((FIT_WARM_UP_EXERCISE_NAME)61) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_SCORPION ((FIT_WARM_UP_EXERCISE_NAME)62) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_SHOULDER ((FIT_WARM_UP_EXERCISE_NAME)63) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_SIDE ((FIT_WARM_UP_EXERCISE_NAME)64) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_SIDE_LUNGE ((FIT_WARM_UP_EXERCISE_NAME)65) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_SIDE_SPLIT ((FIT_WARM_UP_EXERCISE_NAME)66) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_STANDING_IT_BAND ((FIT_WARM_UP_EXERCISE_NAME)67) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_STRADDLE ((FIT_WARM_UP_EXERCISE_NAME)68) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_TRICEPS ((FIT_WARM_UP_EXERCISE_NAME)69) +#define FIT_WARM_UP_EXERCISE_NAME_STRETCH_WALL_CHEST_AND_SHOULDER ((FIT_WARM_UP_EXERCISE_NAME)70) +#define FIT_WARM_UP_EXERCISE_NAME_NECK_ROTATIONS_WHEELCHAIR ((FIT_WARM_UP_EXERCISE_NAME)71) +#define FIT_WARM_UP_EXERCISE_NAME_HALF_KNEELING_ARM_ROTATION ((FIT_WARM_UP_EXERCISE_NAME)72) +#define FIT_WARM_UP_EXERCISE_NAME_THREE_WAY_ANKLE_MOBILIZATION ((FIT_WARM_UP_EXERCISE_NAME)73) +#define FIT_WARM_UP_EXERCISE_NAME_NINETY_NINETY_HIP_SWITCH ((FIT_WARM_UP_EXERCISE_NAME)74) // 90_90_hip_switch +#define FIT_WARM_UP_EXERCISE_NAME_ACTIVE_FROG ((FIT_WARM_UP_EXERCISE_NAME)75) +#define FIT_WARM_UP_EXERCISE_NAME_SHOULDER_SWEEPS ((FIT_WARM_UP_EXERCISE_NAME)76) +#define FIT_WARM_UP_EXERCISE_NAME_ANKLE_LUNGES ((FIT_WARM_UP_EXERCISE_NAME)77) +#define FIT_WARM_UP_EXERCISE_NAME_BACK_ROLL_FOAM_ROLLER ((FIT_WARM_UP_EXERCISE_NAME)78) +#define FIT_WARM_UP_EXERCISE_NAME_BEAR_CRAWL ((FIT_WARM_UP_EXERCISE_NAME)79) +#define FIT_WARM_UP_EXERCISE_NAME_LATISSIMUS_DORSI_FOAM_ROLL ((FIT_WARM_UP_EXERCISE_NAME)80) +#define FIT_WARM_UP_EXERCISE_NAME_REVERSE_T_HIP_OPENER ((FIT_WARM_UP_EXERCISE_NAME)81) +#define FIT_WARM_UP_EXERCISE_NAME_SHOULDER_ROLLS ((FIT_WARM_UP_EXERCISE_NAME)82) +#define FIT_WARM_UP_EXERCISE_NAME_CHEST_OPENERS ((FIT_WARM_UP_EXERCISE_NAME)83) +#define FIT_WARM_UP_EXERCISE_NAME_TRICEPS_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)84) +#define FIT_WARM_UP_EXERCISE_NAME_UPPER_BACK_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)85) +#define FIT_WARM_UP_EXERCISE_NAME_HIP_CIRCLES ((FIT_WARM_UP_EXERCISE_NAME)86) +#define FIT_WARM_UP_EXERCISE_NAME_ANKLE_STRETCH ((FIT_WARM_UP_EXERCISE_NAME)87) +#define FIT_WARM_UP_EXERCISE_NAME_MARCHING_IN_PLACE ((FIT_WARM_UP_EXERCISE_NAME)88) +#define FIT_WARM_UP_EXERCISE_NAME_TRICEPS_STRETCH_WHEELCHAIR ((FIT_WARM_UP_EXERCISE_NAME)89) +#define FIT_WARM_UP_EXERCISE_NAME_UPPER_BACK_STRETCH_WHEELCHAIR ((FIT_WARM_UP_EXERCISE_NAME)90) +#define FIT_WARM_UP_EXERCISE_NAME_COUNT 91 + +typedef FIT_UINT16 FIT_RUN_EXERCISE_NAME; +#define FIT_RUN_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_RUN_EXERCISE_NAME_RUN ((FIT_RUN_EXERCISE_NAME)0) +#define FIT_RUN_EXERCISE_NAME_WALK ((FIT_RUN_EXERCISE_NAME)1) +#define FIT_RUN_EXERCISE_NAME_JOG ((FIT_RUN_EXERCISE_NAME)2) +#define FIT_RUN_EXERCISE_NAME_SPRINT ((FIT_RUN_EXERCISE_NAME)3) +#define FIT_RUN_EXERCISE_NAME_RUN_OR_WALK ((FIT_RUN_EXERCISE_NAME)4) +#define FIT_RUN_EXERCISE_NAME_SPEED_WALK ((FIT_RUN_EXERCISE_NAME)5) +#define FIT_RUN_EXERCISE_NAME_WARM_UP ((FIT_RUN_EXERCISE_NAME)6) +#define FIT_RUN_EXERCISE_NAME_COUNT 7 + +typedef FIT_UINT16 FIT_BIKE_EXERCISE_NAME; +#define FIT_BIKE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_BIKE_EXERCISE_NAME_BIKE ((FIT_BIKE_EXERCISE_NAME)0) +#define FIT_BIKE_EXERCISE_NAME_RIDE ((FIT_BIKE_EXERCISE_NAME)1) +#define FIT_BIKE_EXERCISE_NAME_SPRINT ((FIT_BIKE_EXERCISE_NAME)2) +#define FIT_BIKE_EXERCISE_NAME_COUNT 3 + +typedef FIT_UINT16 FIT_BANDED_EXERCISES_EXERCISE_NAME; +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_AB_TWIST ((FIT_BANDED_EXERCISES_EXERCISE_NAME)1) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_BACK_EXTENSION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)2) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_BICYCLE_CRUNCH ((FIT_BANDED_EXERCISES_EXERCISE_NAME)3) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CALF_RAISES ((FIT_BANDED_EXERCISES_EXERCISE_NAME)4) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CHEST_PRESS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)5) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CLAM_SHELLS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)6) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CURL ((FIT_BANDED_EXERCISES_EXERCISE_NAME)7) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_DEADBUG ((FIT_BANDED_EXERCISES_EXERCISE_NAME)8) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_DEADLIFT ((FIT_BANDED_EXERCISES_EXERCISE_NAME)9) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_DONKEY_KICK ((FIT_BANDED_EXERCISES_EXERCISE_NAME)10) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_EXTERNAL_ROTATION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)11) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_EXTERNAL_ROTATION_AT_90_DEGREE_ABDUCTION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)12) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_FACE_PULL ((FIT_BANDED_EXERCISES_EXERCISE_NAME)13) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_FIRE_HYDRANT ((FIT_BANDED_EXERCISES_EXERCISE_NAME)14) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_FLY ((FIT_BANDED_EXERCISES_EXERCISE_NAME)15) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_FRONT_RAISE ((FIT_BANDED_EXERCISES_EXERCISE_NAME)16) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_GLUTE_BRIDGE ((FIT_BANDED_EXERCISES_EXERCISE_NAME)17) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_HAMSTRING_CURLS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)18) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_HIGH_PLANK_LEG_LIFTS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)19) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_HIP_EXTENSION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)20) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_INTERNAL_ROTATION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)21) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_JUMPING_JACK ((FIT_BANDED_EXERCISES_EXERCISE_NAME)22) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_KNEELING_CRUNCH ((FIT_BANDED_EXERCISES_EXERCISE_NAME)23) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LATERAL_BAND_WALKS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)24) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LATERAL_RAISE ((FIT_BANDED_EXERCISES_EXERCISE_NAME)25) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LATPULL ((FIT_BANDED_EXERCISES_EXERCISE_NAME)26) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LEG_ABDUCTION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)27) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LEG_ADDUCTION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)28) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LEG_EXTENSION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)29) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LUNGE ((FIT_BANDED_EXERCISES_EXERCISE_NAME)30) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_PLANK ((FIT_BANDED_EXERCISES_EXERCISE_NAME)31) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_PULL_APART ((FIT_BANDED_EXERCISES_EXERCISE_NAME)32) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_PUSH_UPS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)33) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_REVERSE_CRUNCH ((FIT_BANDED_EXERCISES_EXERCISE_NAME)34) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_ROW ((FIT_BANDED_EXERCISES_EXERCISE_NAME)35) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SHOULDER_ABDUCTION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)36) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SHOULDER_EXTENSION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)37) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SHOULDER_EXTERNAL_ROTATION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)38) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SHOULDER_FLEXION_TO_90_DEGREES ((FIT_BANDED_EXERCISES_EXERCISE_NAME)39) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SIDE_PLANK_LEG_LIFTS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)40) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SIDE_RAISE ((FIT_BANDED_EXERCISES_EXERCISE_NAME)41) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SQUAT ((FIT_BANDED_EXERCISES_EXERCISE_NAME)42) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SQUAT_TO_PRESS ((FIT_BANDED_EXERCISES_EXERCISE_NAME)43) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_TRICEP_EXTENSION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)44) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_TRICEP_KICKBACK ((FIT_BANDED_EXERCISES_EXERCISE_NAME)45) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_UPRIGHT_ROW ((FIT_BANDED_EXERCISES_EXERCISE_NAME)46) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_WALL_CRAWL_WITH_EXTERNAL_ROTATION ((FIT_BANDED_EXERCISES_EXERCISE_NAME)47) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_LATERAL_RAISE_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)49) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_TRICEPS_EXTENSION_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)50) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CHEST_FLY_INCLINE_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)51) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CHEST_FLY_DECLINE_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)52) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_PULL_DOWN_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)53) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_STRAIGHT_ARM_PULL_DOWN_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)54) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_CURL_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)55) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_OVERHEAD_CURL_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)56) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_FACE_PULL_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)57) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_AROUND_THE_WORLD_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)58) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_PULL_APART_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)59) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_SIDE_CURL_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)60) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_OVERHEAD_PRESS_WHEELCHAIR ((FIT_BANDED_EXERCISES_EXERCISE_NAME)61) +#define FIT_BANDED_EXERCISES_EXERCISE_NAME_COUNT 60 + +typedef FIT_UINT16 FIT_BATTLE_ROPE_EXERCISE_NAME; +#define FIT_BATTLE_ROPE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_FIGURE_EIGHT ((FIT_BATTLE_ROPE_EXERCISE_NAME)0) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_JUMP_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)1) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_KNEELING_TO_STANDING_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)2) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_LUNGE_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)3) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_SQUAT_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)4) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)5) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ALTERNATING_WAVE_WITH_LATERAL_SHUFFLE ((FIT_BATTLE_ROPE_EXERCISE_NAME)6) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_CLAP_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)7) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_DOUBLE_ARM_FIGURE_EIGHT ((FIT_BATTLE_ROPE_EXERCISE_NAME)8) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_DOUBLE_ARM_SIDE_TO_SIDE_SNAKE ((FIT_BATTLE_ROPE_EXERCISE_NAME)9) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_DOUBLE_ARM_SIDE_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)10) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_DOUBLE_ARM_SLAM ((FIT_BATTLE_ROPE_EXERCISE_NAME)11) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_DOUBLE_ARM_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)12) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_GRAPPLER_TOSS ((FIT_BATTLE_ROPE_EXERCISE_NAME)13) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_HIP_TOSS ((FIT_BATTLE_ROPE_EXERCISE_NAME)14) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_IN_AND_OUT_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)15) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_INSIDE_CIRCLE ((FIT_BATTLE_ROPE_EXERCISE_NAME)16) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_JUMPING_JACKS ((FIT_BATTLE_ROPE_EXERCISE_NAME)17) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_OUTSIDE_CIRCLE ((FIT_BATTLE_ROPE_EXERCISE_NAME)18) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_RAINBOW ((FIT_BATTLE_ROPE_EXERCISE_NAME)19) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_SIDE_PLANK_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)20) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_SIDEWINDER ((FIT_BATTLE_ROPE_EXERCISE_NAME)21) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_SITTING_RUSSIAN_TWIST ((FIT_BATTLE_ROPE_EXERCISE_NAME)22) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_SNAKE_WAVE ((FIT_BATTLE_ROPE_EXERCISE_NAME)23) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_SPLIT_JACK ((FIT_BATTLE_ROPE_EXERCISE_NAME)24) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_STAGE_COACH ((FIT_BATTLE_ROPE_EXERCISE_NAME)25) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_ULTIMATE_WARRIOR ((FIT_BATTLE_ROPE_EXERCISE_NAME)26) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_UPPER_CUTS ((FIT_BATTLE_ROPE_EXERCISE_NAME)27) +#define FIT_BATTLE_ROPE_EXERCISE_NAME_COUNT 28 + +typedef FIT_UINT16 FIT_ELLIPTICAL_EXERCISE_NAME; +#define FIT_ELLIPTICAL_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_ELLIPTICAL_EXERCISE_NAME_ELLIPTICAL ((FIT_ELLIPTICAL_EXERCISE_NAME)0) +#define FIT_ELLIPTICAL_EXERCISE_NAME_COUNT 1 + +typedef FIT_UINT16 FIT_FLOOR_CLIMB_EXERCISE_NAME; +#define FIT_FLOOR_CLIMB_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_FLOOR_CLIMB_EXERCISE_NAME_FLOOR_CLIMB ((FIT_FLOOR_CLIMB_EXERCISE_NAME)0) +#define FIT_FLOOR_CLIMB_EXERCISE_NAME_COUNT 1 + +typedef FIT_UINT16 FIT_INDOOR_BIKE_EXERCISE_NAME; +#define FIT_INDOOR_BIKE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_INDOOR_BIKE_EXERCISE_NAME_AIR_BIKE ((FIT_INDOOR_BIKE_EXERCISE_NAME)0) +#define FIT_INDOOR_BIKE_EXERCISE_NAME_ASSAULT_BIKE ((FIT_INDOOR_BIKE_EXERCISE_NAME)1) +#define FIT_INDOOR_BIKE_EXERCISE_NAME_STATIONARY_BIKE ((FIT_INDOOR_BIKE_EXERCISE_NAME)3) +#define FIT_INDOOR_BIKE_EXERCISE_NAME_COUNT 3 + +typedef FIT_UINT16 FIT_INDOOR_ROW_EXERCISE_NAME; +#define FIT_INDOOR_ROW_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_INDOOR_ROW_EXERCISE_NAME_ROWING_MACHINE ((FIT_INDOOR_ROW_EXERCISE_NAME)0) +#define FIT_INDOOR_ROW_EXERCISE_NAME_COUNT 1 + +typedef FIT_UINT16 FIT_LADDER_EXERCISE_NAME; +#define FIT_LADDER_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_LADDER_EXERCISE_NAME_AGILITY ((FIT_LADDER_EXERCISE_NAME)0) +#define FIT_LADDER_EXERCISE_NAME_SPEED ((FIT_LADDER_EXERCISE_NAME)1) +#define FIT_LADDER_EXERCISE_NAME_COUNT 2 + +typedef FIT_UINT16 FIT_SANDBAG_EXERCISE_NAME; +#define FIT_SANDBAG_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SANDBAG_EXERCISE_NAME_AROUND_THE_WORLD ((FIT_SANDBAG_EXERCISE_NAME)0) +#define FIT_SANDBAG_EXERCISE_NAME_BACK_SQUAT ((FIT_SANDBAG_EXERCISE_NAME)1) +#define FIT_SANDBAG_EXERCISE_NAME_BEAR_CRAWL_PULL_THROUGH ((FIT_SANDBAG_EXERCISE_NAME)2) +#define FIT_SANDBAG_EXERCISE_NAME_BEAR_HUG_SQUAT ((FIT_SANDBAG_EXERCISE_NAME)3) +#define FIT_SANDBAG_EXERCISE_NAME_CLEAN ((FIT_SANDBAG_EXERCISE_NAME)4) +#define FIT_SANDBAG_EXERCISE_NAME_CLEAN_AND_PRESS ((FIT_SANDBAG_EXERCISE_NAME)5) +#define FIT_SANDBAG_EXERCISE_NAME_CURL ((FIT_SANDBAG_EXERCISE_NAME)6) +#define FIT_SANDBAG_EXERCISE_NAME_FRONT_CARRY ((FIT_SANDBAG_EXERCISE_NAME)7) +#define FIT_SANDBAG_EXERCISE_NAME_FRONT_SQUAT ((FIT_SANDBAG_EXERCISE_NAME)8) +#define FIT_SANDBAG_EXERCISE_NAME_LUNGE ((FIT_SANDBAG_EXERCISE_NAME)9) +#define FIT_SANDBAG_EXERCISE_NAME_OVERHEAD_PRESS ((FIT_SANDBAG_EXERCISE_NAME)10) +#define FIT_SANDBAG_EXERCISE_NAME_PLANK_PULL_THROUGH ((FIT_SANDBAG_EXERCISE_NAME)11) +#define FIT_SANDBAG_EXERCISE_NAME_ROTATIONAL_LUNGE ((FIT_SANDBAG_EXERCISE_NAME)12) +#define FIT_SANDBAG_EXERCISE_NAME_ROW ((FIT_SANDBAG_EXERCISE_NAME)13) +#define FIT_SANDBAG_EXERCISE_NAME_RUSSIAN_TWIST ((FIT_SANDBAG_EXERCISE_NAME)14) +#define FIT_SANDBAG_EXERCISE_NAME_SHOULDERING ((FIT_SANDBAG_EXERCISE_NAME)15) +#define FIT_SANDBAG_EXERCISE_NAME_SHOVELING ((FIT_SANDBAG_EXERCISE_NAME)16) +#define FIT_SANDBAG_EXERCISE_NAME_SIDE_LUNGE ((FIT_SANDBAG_EXERCISE_NAME)17) +#define FIT_SANDBAG_EXERCISE_NAME_SPRINT ((FIT_SANDBAG_EXERCISE_NAME)18) +#define FIT_SANDBAG_EXERCISE_NAME_ZERCHER_SQUAT ((FIT_SANDBAG_EXERCISE_NAME)19) +#define FIT_SANDBAG_EXERCISE_NAME_COUNT 20 + +typedef FIT_UINT16 FIT_SLED_EXERCISE_NAME; +#define FIT_SLED_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SLED_EXERCISE_NAME_BACKWARD_DRAG ((FIT_SLED_EXERCISE_NAME)0) +#define FIT_SLED_EXERCISE_NAME_CHEST_PRESS ((FIT_SLED_EXERCISE_NAME)1) +#define FIT_SLED_EXERCISE_NAME_FORWARD_DRAG ((FIT_SLED_EXERCISE_NAME)2) +#define FIT_SLED_EXERCISE_NAME_LOW_PUSH ((FIT_SLED_EXERCISE_NAME)3) +#define FIT_SLED_EXERCISE_NAME_PUSH ((FIT_SLED_EXERCISE_NAME)4) +#define FIT_SLED_EXERCISE_NAME_ROW ((FIT_SLED_EXERCISE_NAME)5) +#define FIT_SLED_EXERCISE_NAME_COUNT 6 + +typedef FIT_UINT16 FIT_SLEDGE_HAMMER_EXERCISE_NAME; +#define FIT_SLEDGE_HAMMER_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SLEDGE_HAMMER_EXERCISE_NAME_LATERAL_SWING ((FIT_SLEDGE_HAMMER_EXERCISE_NAME)0) +#define FIT_SLEDGE_HAMMER_EXERCISE_NAME_HAMMER_SLAM ((FIT_SLEDGE_HAMMER_EXERCISE_NAME)1) +#define FIT_SLEDGE_HAMMER_EXERCISE_NAME_COUNT 2 + +typedef FIT_UINT16 FIT_STAIR_STEPPER_EXERCISE_NAME; +#define FIT_STAIR_STEPPER_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_STAIR_STEPPER_EXERCISE_NAME_STAIR_STEPPER ((FIT_STAIR_STEPPER_EXERCISE_NAME)0) +#define FIT_STAIR_STEPPER_EXERCISE_NAME_COUNT 1 + +typedef FIT_UINT16 FIT_SUSPENSION_EXERCISE_NAME; +#define FIT_SUSPENSION_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_SUSPENSION_EXERCISE_NAME_CHEST_FLY ((FIT_SUSPENSION_EXERCISE_NAME)0) +#define FIT_SUSPENSION_EXERCISE_NAME_CHEST_PRESS ((FIT_SUSPENSION_EXERCISE_NAME)1) +#define FIT_SUSPENSION_EXERCISE_NAME_CRUNCH ((FIT_SUSPENSION_EXERCISE_NAME)2) +#define FIT_SUSPENSION_EXERCISE_NAME_CURL ((FIT_SUSPENSION_EXERCISE_NAME)3) +#define FIT_SUSPENSION_EXERCISE_NAME_DIP ((FIT_SUSPENSION_EXERCISE_NAME)4) +#define FIT_SUSPENSION_EXERCISE_NAME_FACE_PULL ((FIT_SUSPENSION_EXERCISE_NAME)5) +#define FIT_SUSPENSION_EXERCISE_NAME_GLUTE_BRIDGE ((FIT_SUSPENSION_EXERCISE_NAME)6) +#define FIT_SUSPENSION_EXERCISE_NAME_HAMSTRING_CURL ((FIT_SUSPENSION_EXERCISE_NAME)7) +#define FIT_SUSPENSION_EXERCISE_NAME_HIP_DROP ((FIT_SUSPENSION_EXERCISE_NAME)8) +#define FIT_SUSPENSION_EXERCISE_NAME_INVERTED_ROW ((FIT_SUSPENSION_EXERCISE_NAME)9) +#define FIT_SUSPENSION_EXERCISE_NAME_KNEE_DRIVE_JUMP ((FIT_SUSPENSION_EXERCISE_NAME)10) +#define FIT_SUSPENSION_EXERCISE_NAME_KNEE_TO_CHEST ((FIT_SUSPENSION_EXERCISE_NAME)11) +#define FIT_SUSPENSION_EXERCISE_NAME_LAT_PULLOVER ((FIT_SUSPENSION_EXERCISE_NAME)12) +#define FIT_SUSPENSION_EXERCISE_NAME_LUNGE ((FIT_SUSPENSION_EXERCISE_NAME)13) +#define FIT_SUSPENSION_EXERCISE_NAME_MOUNTAIN_CLIMBER ((FIT_SUSPENSION_EXERCISE_NAME)14) +#define FIT_SUSPENSION_EXERCISE_NAME_PENDULUM ((FIT_SUSPENSION_EXERCISE_NAME)15) +#define FIT_SUSPENSION_EXERCISE_NAME_PIKE ((FIT_SUSPENSION_EXERCISE_NAME)16) +#define FIT_SUSPENSION_EXERCISE_NAME_PLANK ((FIT_SUSPENSION_EXERCISE_NAME)17) +#define FIT_SUSPENSION_EXERCISE_NAME_POWER_PULL ((FIT_SUSPENSION_EXERCISE_NAME)18) +#define FIT_SUSPENSION_EXERCISE_NAME_PULL_UP ((FIT_SUSPENSION_EXERCISE_NAME)19) +#define FIT_SUSPENSION_EXERCISE_NAME_PUSH_UP ((FIT_SUSPENSION_EXERCISE_NAME)20) +#define FIT_SUSPENSION_EXERCISE_NAME_REVERSE_MOUNTAIN_CLIMBER ((FIT_SUSPENSION_EXERCISE_NAME)21) +#define FIT_SUSPENSION_EXERCISE_NAME_REVERSE_PLANK ((FIT_SUSPENSION_EXERCISE_NAME)22) +#define FIT_SUSPENSION_EXERCISE_NAME_ROLLOUT ((FIT_SUSPENSION_EXERCISE_NAME)23) +#define FIT_SUSPENSION_EXERCISE_NAME_ROW ((FIT_SUSPENSION_EXERCISE_NAME)24) +#define FIT_SUSPENSION_EXERCISE_NAME_SIDE_LUNGE ((FIT_SUSPENSION_EXERCISE_NAME)25) +#define FIT_SUSPENSION_EXERCISE_NAME_SIDE_PLANK ((FIT_SUSPENSION_EXERCISE_NAME)26) +#define FIT_SUSPENSION_EXERCISE_NAME_SINGLE_LEG_DEADLIFT ((FIT_SUSPENSION_EXERCISE_NAME)27) +#define FIT_SUSPENSION_EXERCISE_NAME_SINGLE_LEG_SQUAT ((FIT_SUSPENSION_EXERCISE_NAME)28) +#define FIT_SUSPENSION_EXERCISE_NAME_SIT_UP ((FIT_SUSPENSION_EXERCISE_NAME)29) +#define FIT_SUSPENSION_EXERCISE_NAME_SPLIT ((FIT_SUSPENSION_EXERCISE_NAME)30) +#define FIT_SUSPENSION_EXERCISE_NAME_SQUAT ((FIT_SUSPENSION_EXERCISE_NAME)31) +#define FIT_SUSPENSION_EXERCISE_NAME_SQUAT_JUMP ((FIT_SUSPENSION_EXERCISE_NAME)32) +#define FIT_SUSPENSION_EXERCISE_NAME_TRICEP_PRESS ((FIT_SUSPENSION_EXERCISE_NAME)33) +#define FIT_SUSPENSION_EXERCISE_NAME_Y_FLY ((FIT_SUSPENSION_EXERCISE_NAME)34) +#define FIT_SUSPENSION_EXERCISE_NAME_COUNT 35 + +typedef FIT_UINT16 FIT_TIRE_EXERCISE_NAME; +#define FIT_TIRE_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_TIRE_EXERCISE_NAME_FLIP ((FIT_TIRE_EXERCISE_NAME)0) +#define FIT_TIRE_EXERCISE_NAME_COUNT 1 + +typedef FIT_UINT16 FIT_BIKE_OUTDOOR_EXERCISE_NAME; +#define FIT_BIKE_OUTDOOR_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_BIKE_OUTDOOR_EXERCISE_NAME_BIKE ((FIT_BIKE_OUTDOOR_EXERCISE_NAME)0) +#define FIT_BIKE_OUTDOOR_EXERCISE_NAME_COUNT 1 + +typedef FIT_UINT16 FIT_RUN_INDOOR_EXERCISE_NAME; +#define FIT_RUN_INDOOR_EXERCISE_NAME_INVALID FIT_UINT16_INVALID +#define FIT_RUN_INDOOR_EXERCISE_NAME_INDOOR_TRACK_RUN ((FIT_RUN_INDOOR_EXERCISE_NAME)0) +#define FIT_RUN_INDOOR_EXERCISE_NAME_TREADMILL ((FIT_RUN_INDOOR_EXERCISE_NAME)1) +#define FIT_RUN_INDOOR_EXERCISE_NAME_COUNT 2 + +typedef FIT_ENUM FIT_WATER_TYPE; +#define FIT_WATER_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_WATER_TYPE_FRESH ((FIT_WATER_TYPE)0) +#define FIT_WATER_TYPE_SALT ((FIT_WATER_TYPE)1) +#define FIT_WATER_TYPE_EN13319 ((FIT_WATER_TYPE)2) +#define FIT_WATER_TYPE_CUSTOM ((FIT_WATER_TYPE)3) +#define FIT_WATER_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_TISSUE_MODEL_TYPE; +#define FIT_TISSUE_MODEL_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_TISSUE_MODEL_TYPE_ZHL_16C ((FIT_TISSUE_MODEL_TYPE)0) // Buhlmann's decompression algorithm, version C +#define FIT_TISSUE_MODEL_TYPE_COUNT 1 + +typedef FIT_ENUM FIT_DIVE_GAS_STATUS; +#define FIT_DIVE_GAS_STATUS_INVALID FIT_ENUM_INVALID +#define FIT_DIVE_GAS_STATUS_DISABLED ((FIT_DIVE_GAS_STATUS)0) +#define FIT_DIVE_GAS_STATUS_ENABLED ((FIT_DIVE_GAS_STATUS)1) +#define FIT_DIVE_GAS_STATUS_BACKUP_ONLY ((FIT_DIVE_GAS_STATUS)2) +#define FIT_DIVE_GAS_STATUS_COUNT 3 + +typedef FIT_ENUM FIT_DIVE_ALERT; +#define FIT_DIVE_ALERT_INVALID FIT_ENUM_INVALID +#define FIT_DIVE_ALERT_NDL_REACHED ((FIT_DIVE_ALERT)0) +#define FIT_DIVE_ALERT_GAS_SWITCH_PROMPTED ((FIT_DIVE_ALERT)1) +#define FIT_DIVE_ALERT_NEAR_SURFACE ((FIT_DIVE_ALERT)2) +#define FIT_DIVE_ALERT_APPROACHING_NDL ((FIT_DIVE_ALERT)3) +#define FIT_DIVE_ALERT_PO2_WARN ((FIT_DIVE_ALERT)4) +#define FIT_DIVE_ALERT_PO2_CRIT_HIGH ((FIT_DIVE_ALERT)5) +#define FIT_DIVE_ALERT_PO2_CRIT_LOW ((FIT_DIVE_ALERT)6) +#define FIT_DIVE_ALERT_TIME_ALERT ((FIT_DIVE_ALERT)7) +#define FIT_DIVE_ALERT_DEPTH_ALERT ((FIT_DIVE_ALERT)8) +#define FIT_DIVE_ALERT_DECO_CEILING_BROKEN ((FIT_DIVE_ALERT)9) +#define FIT_DIVE_ALERT_DECO_COMPLETE ((FIT_DIVE_ALERT)10) +#define FIT_DIVE_ALERT_SAFETY_STOP_BROKEN ((FIT_DIVE_ALERT)11) +#define FIT_DIVE_ALERT_SAFETY_STOP_COMPLETE ((FIT_DIVE_ALERT)12) +#define FIT_DIVE_ALERT_CNS_WARNING ((FIT_DIVE_ALERT)13) +#define FIT_DIVE_ALERT_CNS_CRITICAL ((FIT_DIVE_ALERT)14) +#define FIT_DIVE_ALERT_OTU_WARNING ((FIT_DIVE_ALERT)15) +#define FIT_DIVE_ALERT_OTU_CRITICAL ((FIT_DIVE_ALERT)16) +#define FIT_DIVE_ALERT_ASCENT_CRITICAL ((FIT_DIVE_ALERT)17) +#define FIT_DIVE_ALERT_ALERT_DISMISSED_BY_KEY ((FIT_DIVE_ALERT)18) +#define FIT_DIVE_ALERT_ALERT_DISMISSED_BY_TIMEOUT ((FIT_DIVE_ALERT)19) +#define FIT_DIVE_ALERT_BATTERY_LOW ((FIT_DIVE_ALERT)20) +#define FIT_DIVE_ALERT_BATTERY_CRITICAL ((FIT_DIVE_ALERT)21) +#define FIT_DIVE_ALERT_SAFETY_STOP_STARTED ((FIT_DIVE_ALERT)22) +#define FIT_DIVE_ALERT_APPROACHING_FIRST_DECO_STOP ((FIT_DIVE_ALERT)23) +#define FIT_DIVE_ALERT_SETPOINT_SWITCH_AUTO_LOW ((FIT_DIVE_ALERT)24) +#define FIT_DIVE_ALERT_SETPOINT_SWITCH_AUTO_HIGH ((FIT_DIVE_ALERT)25) +#define FIT_DIVE_ALERT_SETPOINT_SWITCH_MANUAL_LOW ((FIT_DIVE_ALERT)26) +#define FIT_DIVE_ALERT_SETPOINT_SWITCH_MANUAL_HIGH ((FIT_DIVE_ALERT)27) +#define FIT_DIVE_ALERT_AUTO_SETPOINT_SWITCH_IGNORED ((FIT_DIVE_ALERT)28) +#define FIT_DIVE_ALERT_SWITCHED_TO_OPEN_CIRCUIT ((FIT_DIVE_ALERT)29) +#define FIT_DIVE_ALERT_SWITCHED_TO_CLOSED_CIRCUIT ((FIT_DIVE_ALERT)30) +#define FIT_DIVE_ALERT_TANK_BATTERY_LOW ((FIT_DIVE_ALERT)32) +#define FIT_DIVE_ALERT_PO2_CCR_DIL_LOW ((FIT_DIVE_ALERT)33) // ccr diluent has low po2 +#define FIT_DIVE_ALERT_DECO_STOP_CLEARED ((FIT_DIVE_ALERT)34) // a deco stop has been cleared +#define FIT_DIVE_ALERT_APNEA_NEUTRAL_BUOYANCY ((FIT_DIVE_ALERT)35) // Target Depth Apnea Alarm triggered +#define FIT_DIVE_ALERT_APNEA_TARGET_DEPTH ((FIT_DIVE_ALERT)36) // Neutral Buoyance Apnea Alarm triggered +#define FIT_DIVE_ALERT_APNEA_SURFACE ((FIT_DIVE_ALERT)37) // Surface Apnea Alarm triggered +#define FIT_DIVE_ALERT_APNEA_HIGH_SPEED ((FIT_DIVE_ALERT)38) // High Speed Apnea Alarm triggered +#define FIT_DIVE_ALERT_APNEA_LOW_SPEED ((FIT_DIVE_ALERT)39) // Low Speed Apnea Alarm triggered +#define FIT_DIVE_ALERT_COUNT 39 + +typedef FIT_ENUM FIT_DIVE_ALARM_TYPE; +#define FIT_DIVE_ALARM_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_DIVE_ALARM_TYPE_DEPTH ((FIT_DIVE_ALARM_TYPE)0) // Alarm when a certain depth is crossed +#define FIT_DIVE_ALARM_TYPE_TIME ((FIT_DIVE_ALARM_TYPE)1) // Alarm when a certain time has transpired +#define FIT_DIVE_ALARM_TYPE_SPEED ((FIT_DIVE_ALARM_TYPE)2) // Alarm when a certain ascent or descent rate is exceeded +#define FIT_DIVE_ALARM_TYPE_COUNT 3 + +typedef FIT_ENUM FIT_DIVE_BACKLIGHT_MODE; +#define FIT_DIVE_BACKLIGHT_MODE_INVALID FIT_ENUM_INVALID +#define FIT_DIVE_BACKLIGHT_MODE_AT_DEPTH ((FIT_DIVE_BACKLIGHT_MODE)0) +#define FIT_DIVE_BACKLIGHT_MODE_ALWAYS_ON ((FIT_DIVE_BACKLIGHT_MODE)1) +#define FIT_DIVE_BACKLIGHT_MODE_COUNT 2 + +typedef FIT_ENUM FIT_SLEEP_LEVEL; +#define FIT_SLEEP_LEVEL_INVALID FIT_ENUM_INVALID +#define FIT_SLEEP_LEVEL_UNMEASURABLE ((FIT_SLEEP_LEVEL)0) +#define FIT_SLEEP_LEVEL_AWAKE ((FIT_SLEEP_LEVEL)1) +#define FIT_SLEEP_LEVEL_LIGHT ((FIT_SLEEP_LEVEL)2) +#define FIT_SLEEP_LEVEL_DEEP ((FIT_SLEEP_LEVEL)3) +#define FIT_SLEEP_LEVEL_REM ((FIT_SLEEP_LEVEL)4) +#define FIT_SLEEP_LEVEL_COUNT 5 + +typedef FIT_ENUM FIT_SPO2_MEASUREMENT_TYPE; +#define FIT_SPO2_MEASUREMENT_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_SPO2_MEASUREMENT_TYPE_OFF_WRIST ((FIT_SPO2_MEASUREMENT_TYPE)0) +#define FIT_SPO2_MEASUREMENT_TYPE_SPOT_CHECK ((FIT_SPO2_MEASUREMENT_TYPE)1) +#define FIT_SPO2_MEASUREMENT_TYPE_CONTINUOUS_CHECK ((FIT_SPO2_MEASUREMENT_TYPE)2) +#define FIT_SPO2_MEASUREMENT_TYPE_PERIODIC ((FIT_SPO2_MEASUREMENT_TYPE)3) +#define FIT_SPO2_MEASUREMENT_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_CCR_SETPOINT_SWITCH_MODE; +#define FIT_CCR_SETPOINT_SWITCH_MODE_INVALID FIT_ENUM_INVALID +#define FIT_CCR_SETPOINT_SWITCH_MODE_MANUAL ((FIT_CCR_SETPOINT_SWITCH_MODE)0) // User switches setpoints manually +#define FIT_CCR_SETPOINT_SWITCH_MODE_AUTOMATIC ((FIT_CCR_SETPOINT_SWITCH_MODE)1) // Switch automatically based on depth +#define FIT_CCR_SETPOINT_SWITCH_MODE_COUNT 2 + +typedef FIT_ENUM FIT_DIVE_GAS_MODE; +#define FIT_DIVE_GAS_MODE_INVALID FIT_ENUM_INVALID +#define FIT_DIVE_GAS_MODE_OPEN_CIRCUIT ((FIT_DIVE_GAS_MODE)0) +#define FIT_DIVE_GAS_MODE_CLOSED_CIRCUIT_DILUENT ((FIT_DIVE_GAS_MODE)1) +#define FIT_DIVE_GAS_MODE_COUNT 2 + +typedef FIT_ENUM FIT_PROJECTILE_TYPE; +#define FIT_PROJECTILE_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_PROJECTILE_TYPE_ARROW ((FIT_PROJECTILE_TYPE)0) // Arrow projectile type +#define FIT_PROJECTILE_TYPE_RIFLE_CARTRIDGE ((FIT_PROJECTILE_TYPE)1) // Rifle cartridge projectile type +#define FIT_PROJECTILE_TYPE_PISTOL_CARTRIDGE ((FIT_PROJECTILE_TYPE)2) // Pistol cartridge projectile type +#define FIT_PROJECTILE_TYPE_SHOTSHELL ((FIT_PROJECTILE_TYPE)3) // Shotshell projectile type +#define FIT_PROJECTILE_TYPE_AIR_RIFLE_PELLET ((FIT_PROJECTILE_TYPE)4) // Air rifle pellet projectile type +#define FIT_PROJECTILE_TYPE_OTHER ((FIT_PROJECTILE_TYPE)5) // Other projectile type +#define FIT_PROJECTILE_TYPE_COUNT 6 + +typedef FIT_UINT16 FIT_FAVERO_PRODUCT; +#define FIT_FAVERO_PRODUCT_INVALID FIT_UINT16_INVALID +#define FIT_FAVERO_PRODUCT_ASSIOMA_UNO ((FIT_FAVERO_PRODUCT)10) +#define FIT_FAVERO_PRODUCT_ASSIOMA_DUO ((FIT_FAVERO_PRODUCT)12) +#define FIT_FAVERO_PRODUCT_COUNT 2 + +typedef FIT_ENUM FIT_SPLIT_TYPE; +#define FIT_SPLIT_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_SPLIT_TYPE_ASCENT_SPLIT ((FIT_SPLIT_TYPE)1) +#define FIT_SPLIT_TYPE_DESCENT_SPLIT ((FIT_SPLIT_TYPE)2) +#define FIT_SPLIT_TYPE_INTERVAL_ACTIVE ((FIT_SPLIT_TYPE)3) +#define FIT_SPLIT_TYPE_INTERVAL_REST ((FIT_SPLIT_TYPE)4) +#define FIT_SPLIT_TYPE_INTERVAL_WARMUP ((FIT_SPLIT_TYPE)5) +#define FIT_SPLIT_TYPE_INTERVAL_COOLDOWN ((FIT_SPLIT_TYPE)6) +#define FIT_SPLIT_TYPE_INTERVAL_RECOVERY ((FIT_SPLIT_TYPE)7) +#define FIT_SPLIT_TYPE_INTERVAL_OTHER ((FIT_SPLIT_TYPE)8) +#define FIT_SPLIT_TYPE_CLIMB_ACTIVE ((FIT_SPLIT_TYPE)9) +#define FIT_SPLIT_TYPE_CLIMB_REST ((FIT_SPLIT_TYPE)10) +#define FIT_SPLIT_TYPE_SURF_ACTIVE ((FIT_SPLIT_TYPE)11) +#define FIT_SPLIT_TYPE_RUN_ACTIVE ((FIT_SPLIT_TYPE)12) +#define FIT_SPLIT_TYPE_RUN_REST ((FIT_SPLIT_TYPE)13) +#define FIT_SPLIT_TYPE_WORKOUT_ROUND ((FIT_SPLIT_TYPE)14) +#define FIT_SPLIT_TYPE_RWD_RUN ((FIT_SPLIT_TYPE)17) // run/walk detection running +#define FIT_SPLIT_TYPE_RWD_WALK ((FIT_SPLIT_TYPE)18) // run/walk detection walking +#define FIT_SPLIT_TYPE_WINDSURF_ACTIVE ((FIT_SPLIT_TYPE)21) +#define FIT_SPLIT_TYPE_RWD_STAND ((FIT_SPLIT_TYPE)22) // run/walk detection standing +#define FIT_SPLIT_TYPE_TRANSITION ((FIT_SPLIT_TYPE)23) // Marks the time going from ascent_split to descent_split/used in backcountry ski +#define FIT_SPLIT_TYPE_SKI_LIFT_SPLIT ((FIT_SPLIT_TYPE)28) +#define FIT_SPLIT_TYPE_SKI_RUN_SPLIT ((FIT_SPLIT_TYPE)29) +#define FIT_SPLIT_TYPE_COUNT 21 + +typedef FIT_ENUM FIT_CLIMB_PRO_EVENT; +#define FIT_CLIMB_PRO_EVENT_INVALID FIT_ENUM_INVALID +#define FIT_CLIMB_PRO_EVENT_APPROACH ((FIT_CLIMB_PRO_EVENT)0) +#define FIT_CLIMB_PRO_EVENT_START ((FIT_CLIMB_PRO_EVENT)1) +#define FIT_CLIMB_PRO_EVENT_COMPLETE ((FIT_CLIMB_PRO_EVENT)2) +#define FIT_CLIMB_PRO_EVENT_COUNT 3 + +typedef FIT_ENUM FIT_GAS_CONSUMPTION_RATE_TYPE; +#define FIT_GAS_CONSUMPTION_RATE_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_GAS_CONSUMPTION_RATE_TYPE_PRESSURE_SAC ((FIT_GAS_CONSUMPTION_RATE_TYPE)0) // Pressure-based Surface Air Consumption +#define FIT_GAS_CONSUMPTION_RATE_TYPE_VOLUME_SAC ((FIT_GAS_CONSUMPTION_RATE_TYPE)1) // Volumetric Surface Air Consumption +#define FIT_GAS_CONSUMPTION_RATE_TYPE_RMV ((FIT_GAS_CONSUMPTION_RATE_TYPE)2) // Respiratory Minute Volume +#define FIT_GAS_CONSUMPTION_RATE_TYPE_COUNT 3 + +typedef FIT_ENUM FIT_TAP_SENSITIVITY; +#define FIT_TAP_SENSITIVITY_INVALID FIT_ENUM_INVALID +#define FIT_TAP_SENSITIVITY_HIGH ((FIT_TAP_SENSITIVITY)0) +#define FIT_TAP_SENSITIVITY_MEDIUM ((FIT_TAP_SENSITIVITY)1) +#define FIT_TAP_SENSITIVITY_LOW ((FIT_TAP_SENSITIVITY)2) +#define FIT_TAP_SENSITIVITY_COUNT 3 + +typedef FIT_ENUM FIT_RADAR_THREAT_LEVEL_TYPE; +#define FIT_RADAR_THREAT_LEVEL_TYPE_INVALID FIT_ENUM_INVALID +#define FIT_RADAR_THREAT_LEVEL_TYPE_THREAT_UNKNOWN ((FIT_RADAR_THREAT_LEVEL_TYPE)0) +#define FIT_RADAR_THREAT_LEVEL_TYPE_THREAT_NONE ((FIT_RADAR_THREAT_LEVEL_TYPE)1) +#define FIT_RADAR_THREAT_LEVEL_TYPE_THREAT_APPROACHING ((FIT_RADAR_THREAT_LEVEL_TYPE)2) +#define FIT_RADAR_THREAT_LEVEL_TYPE_THREAT_APPROACHING_FAST ((FIT_RADAR_THREAT_LEVEL_TYPE)3) +#define FIT_RADAR_THREAT_LEVEL_TYPE_COUNT 4 + +typedef FIT_ENUM FIT_SLEEP_DISRUPTION_SEVERITY; +#define FIT_SLEEP_DISRUPTION_SEVERITY_INVALID FIT_ENUM_INVALID +#define FIT_SLEEP_DISRUPTION_SEVERITY_NONE ((FIT_SLEEP_DISRUPTION_SEVERITY)0) +#define FIT_SLEEP_DISRUPTION_SEVERITY_LOW ((FIT_SLEEP_DISRUPTION_SEVERITY)1) +#define FIT_SLEEP_DISRUPTION_SEVERITY_MEDIUM ((FIT_SLEEP_DISRUPTION_SEVERITY)2) +#define FIT_SLEEP_DISRUPTION_SEVERITY_HIGH ((FIT_SLEEP_DISRUPTION_SEVERITY)3) +#define FIT_SLEEP_DISRUPTION_SEVERITY_COUNT 4 + +typedef FIT_ENUM FIT_MAX_MET_SPEED_SOURCE; +#define FIT_MAX_MET_SPEED_SOURCE_INVALID FIT_ENUM_INVALID +#define FIT_MAX_MET_SPEED_SOURCE_ONBOARD_GPS ((FIT_MAX_MET_SPEED_SOURCE)0) +#define FIT_MAX_MET_SPEED_SOURCE_CONNECTED_GPS ((FIT_MAX_MET_SPEED_SOURCE)1) +#define FIT_MAX_MET_SPEED_SOURCE_CADENCE ((FIT_MAX_MET_SPEED_SOURCE)2) +#define FIT_MAX_MET_SPEED_SOURCE_COUNT 3 + +typedef FIT_ENUM FIT_MAX_MET_HEART_RATE_SOURCE; +#define FIT_MAX_MET_HEART_RATE_SOURCE_INVALID FIT_ENUM_INVALID +#define FIT_MAX_MET_HEART_RATE_SOURCE_WHR ((FIT_MAX_MET_HEART_RATE_SOURCE)0) // Wrist Heart Rate Monitor +#define FIT_MAX_MET_HEART_RATE_SOURCE_HRM ((FIT_MAX_MET_HEART_RATE_SOURCE)1) // Chest Strap Heart Rate Monitor +#define FIT_MAX_MET_HEART_RATE_SOURCE_COUNT 2 + +typedef FIT_ENUM FIT_HRV_STATUS; +#define FIT_HRV_STATUS_INVALID FIT_ENUM_INVALID +#define FIT_HRV_STATUS_NONE ((FIT_HRV_STATUS)0) +#define FIT_HRV_STATUS_POOR ((FIT_HRV_STATUS)1) +#define FIT_HRV_STATUS_LOW ((FIT_HRV_STATUS)2) +#define FIT_HRV_STATUS_UNBALANCED ((FIT_HRV_STATUS)3) +#define FIT_HRV_STATUS_BALANCED ((FIT_HRV_STATUS)4) +#define FIT_HRV_STATUS_COUNT 5 + +typedef FIT_ENUM FIT_NO_FLY_TIME_MODE; +#define FIT_NO_FLY_TIME_MODE_INVALID FIT_ENUM_INVALID +#define FIT_NO_FLY_TIME_MODE_STANDARD ((FIT_NO_FLY_TIME_MODE)0) // Standard Diver Alert Network no-fly guidance +#define FIT_NO_FLY_TIME_MODE_FLAT_24_HOURS ((FIT_NO_FLY_TIME_MODE)1) // Flat 24 hour no-fly guidance +#define FIT_NO_FLY_TIME_MODE_COUNT 2 + + +#endif // !defined(FIT_CPP_INCLUDE_C) + +/////////////////////////////////////////////////////////////////////// +// Miscellaneous +/////////////////////////////////////////////////////////////////////// + +#define FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD (FIT_UINT16_INVALID - 1) +#define FIT_SUBFIELD_INDEX_MAIN_FIELD (FIT_UINT16_INVALID) + + +namespace fit +{ + +class Profile +{ +public: + enum class Type + { + Enum, + Sint8, + Uint8, + Sint16, + Uint16, + Sint32, + Uint32, + String, + Float32, + Float64, + Uint8z, + Uint16z, + Uint32z, + Byte, + Sint64, + Uint64, + Uint64z, + Bool, + File, + MesgNum, + Checksum, + FileFlags, + MesgCount, + DateTime, + LocalDateTime, + MessageIndex, + DeviceIndex, + Gender, + Language, + LanguageBits0, + LanguageBits1, + LanguageBits2, + LanguageBits3, + LanguageBits4, + TimeZone, + DisplayMeasure, + DisplayHeart, + DisplayPower, + DisplayPosition, + Switch, + Sport, + SportBits0, + SportBits1, + SportBits2, + SportBits3, + SportBits4, + SportBits5, + SportBits6, + SubSport, + SportEvent, + Activity, + Intensity, + SessionTrigger, + AutolapTrigger, + LapTrigger, + TimeMode, + BacklightMode, + DateMode, + BacklightTimeout, + Event, + EventType, + TimerTrigger, + FitnessEquipmentState, + Tone, + Autoscroll, + ActivityClass, + HrZoneCalc, + PwrZoneCalc, + WktStepDuration, + WktStepTarget, + Goal, + GoalRecurrence, + GoalSource, + Schedule, + CoursePoint, + Manufacturer, + GarminProduct, + AntplusDeviceType, + AntNetwork, + WorkoutCapabilities, + BatteryStatus, + HrType, + CourseCapabilities, + Weight, + WorkoutHr, + WorkoutPower, + BpStatus, + UserLocalId, + SwimStroke, + ActivityType, + ActivitySubtype, + ActivityLevel, + Side, + LeftRightBalance, + LeftRightBalance100, + LengthType, + DayOfWeek, + ConnectivityCapabilities, + WeatherReport, + WeatherStatus, + WeatherSeverity, + WeatherSevereType, + TimeIntoDay, + LocaltimeIntoDay, + StrokeType, + BodyLocation, + SegmentLapStatus, + SegmentLeaderboardType, + SegmentDeleteStatus, + SegmentSelectionType, + SourceType, + LocalDeviceType, + BleDeviceType, + AntChannelId, + DisplayOrientation, + WorkoutEquipment, + WatchfaceMode, + DigitalWatchfaceLayout, + AnalogWatchfaceLayout, + RiderPositionType, + PowerPhaseType, + CameraEventType, + SensorType, + BikeLightNetworkConfigType, + CommTimeoutType, + CameraOrientationType, + AttitudeStage, + AttitudeValidity, + AutoSyncFrequency, + ExdLayout, + ExdDisplayType, + ExdDataUnits, + ExdQualifiers, + ExdDescriptors, + AutoActivityDetect, + SupportedExdScreenLayouts, + FitBaseType, + TurnType, + BikeLightBeamAngleMode, + FitBaseUnit, + SetType, + MaxMetCategory, + ExerciseCategory, + BenchPressExerciseName, + CalfRaiseExerciseName, + CardioExerciseName, + CarryExerciseName, + ChopExerciseName, + CoreExerciseName, + CrunchExerciseName, + CurlExerciseName, + DeadliftExerciseName, + FlyeExerciseName, + HipRaiseExerciseName, + HipStabilityExerciseName, + HipSwingExerciseName, + HyperextensionExerciseName, + LateralRaiseExerciseName, + LegCurlExerciseName, + LegRaiseExerciseName, + LungeExerciseName, + OlympicLiftExerciseName, + PlankExerciseName, + PlyoExerciseName, + PullUpExerciseName, + PushUpExerciseName, + RowExerciseName, + ShoulderPressExerciseName, + ShoulderStabilityExerciseName, + ShrugExerciseName, + SitUpExerciseName, + SquatExerciseName, + TotalBodyExerciseName, + MoveExerciseName, + PoseExerciseName, + TricepsExtensionExerciseName, + WarmUpExerciseName, + RunExerciseName, + BikeExerciseName, + BandedExercisesExerciseName, + BattleRopeExerciseName, + EllipticalExerciseName, + FloorClimbExerciseName, + IndoorBikeExerciseName, + IndoorRowExerciseName, + LadderExerciseName, + SandbagExerciseName, + SledExerciseName, + SledgeHammerExerciseName, + StairStepperExerciseName, + SuspensionExerciseName, + TireExerciseName, + BikeOutdoorExerciseName, + RunIndoorExerciseName, + WaterType, + TissueModelType, + DiveGasStatus, + DiveAlert, + DiveAlarmType, + DiveBacklightMode, + SleepLevel, + Spo2MeasurementType, + CcrSetpointSwitchMode, + DiveGasMode, + ProjectileType, + FaveroProduct, + SplitType, + ClimbProEvent, + GasConsumptionRateType, + TapSensitivity, + RadarThreatLevelType, + SleepDisruptionSeverity, + MaxMetSpeedSource, + MaxMetHeartRateSource, + HrvStatus, + NoFlyTimeMode, + Invalid + }; + + typedef enum + { + MESG_FILE_ID, + MESG_FILE_CREATOR, + MESG_TIMESTAMP_CORRELATION, + MESG_SOFTWARE, + MESG_SLAVE_DEVICE, + MESG_CAPABILITIES, + MESG_FILE_CAPABILITIES, + MESG_MESG_CAPABILITIES, + MESG_FIELD_CAPABILITIES, + MESG_DEVICE_SETTINGS, + MESG_USER_PROFILE, + MESG_HRM_PROFILE, + MESG_SDM_PROFILE, + MESG_BIKE_PROFILE, + MESG_CONNECTIVITY, + MESG_WATCHFACE_SETTINGS, + MESG_OHR_SETTINGS, + MESG_TIME_IN_ZONE, + MESG_ZONES_TARGET, + MESG_SPORT, + MESG_HR_ZONE, + MESG_SPEED_ZONE, + MESG_CADENCE_ZONE, + MESG_POWER_ZONE, + MESG_MET_ZONE, + MESG_TRAINING_SETTINGS, + MESG_DIVE_SETTINGS, + MESG_DIVE_ALARM, + MESG_DIVE_APNEA_ALARM, + MESG_DIVE_GAS, + MESG_GOAL, + MESG_ACTIVITY, + MESG_SESSION, + MESG_LAP, + MESG_LENGTH, + MESG_RECORD, + MESG_EVENT, + MESG_DEVICE_INFO, + MESG_DEVICE_AUX_BATTERY_INFO, + MESG_TRAINING_FILE, + MESG_WEATHER_CONDITIONS, + MESG_WEATHER_ALERT, + MESG_GPS_METADATA, + MESG_CAMERA_EVENT, + MESG_GYROSCOPE_DATA, + MESG_ACCELEROMETER_DATA, + MESG_MAGNETOMETER_DATA, + MESG_BAROMETER_DATA, + MESG_THREE_D_SENSOR_CALIBRATION, + MESG_ONE_D_SENSOR_CALIBRATION, + MESG_VIDEO_FRAME, + MESG_OBDII_DATA, + MESG_NMEA_SENTENCE, + MESG_AVIATION_ATTITUDE, + MESG_VIDEO, + MESG_VIDEO_TITLE, + MESG_VIDEO_DESCRIPTION, + MESG_VIDEO_CLIP, + MESG_SET, + MESG_JUMP, + MESG_SPLIT, + MESG_SPLIT_SUMMARY, + MESG_CLIMB_PRO, + MESG_FIELD_DESCRIPTION, + MESG_DEVELOPER_DATA_ID, + MESG_COURSE, + MESG_COURSE_POINT, + MESG_SEGMENT_ID, + MESG_SEGMENT_LEADERBOARD_ENTRY, + MESG_SEGMENT_POINT, + MESG_SEGMENT_LAP, + MESG_SEGMENT_FILE, + MESG_WORKOUT, + MESG_WORKOUT_SESSION, + MESG_WORKOUT_STEP, + MESG_EXERCISE_TITLE, + MESG_SCHEDULE, + MESG_TOTALS, + MESG_WEIGHT_SCALE, + MESG_BLOOD_PRESSURE, + MESG_MONITORING_INFO, + MESG_MONITORING, + MESG_MONITORING_HR_DATA, + MESG_SPO2_DATA, + MESG_HR, + MESG_STRESS_LEVEL, + MESG_MAX_MET_DATA, + MESG_HSA_BODY_BATTERY_DATA, + MESG_HSA_EVENT, + MESG_HSA_ACCELEROMETER_DATA, + MESG_HSA_GYROSCOPE_DATA, + MESG_HSA_STEP_DATA, + MESG_HSA_SPO2_DATA, + MESG_HSA_STRESS_DATA, + MESG_HSA_RESPIRATION_DATA, + MESG_HSA_HEART_RATE_DATA, + MESG_HSA_CONFIGURATION_DATA, + MESG_HSA_WRIST_TEMPERATURE_DATA, + MESG_MEMO_GLOB, + MESG_SLEEP_LEVEL, + MESG_ANT_CHANNEL_ID, + MESG_ANT_RX, + MESG_ANT_TX, + MESG_EXD_SCREEN_CONFIGURATION, + MESG_EXD_DATA_FIELD_CONFIGURATION, + MESG_EXD_DATA_CONCEPT_CONFIGURATION, + MESG_DIVE_SUMMARY, + MESG_AAD_ACCEL_FEATURES, + MESG_HRV, + MESG_BEAT_INTERVALS, + MESG_HRV_STATUS_SUMMARY, + MESG_HRV_VALUE, + MESG_RAW_BBI, + MESG_RESPIRATION_RATE, + MESG_CHRONO_SHOT_SESSION, + MESG_CHRONO_SHOT_DATA, + MESG_TANK_UPDATE, + MESG_TANK_SUMMARY, + MESG_SLEEP_ASSESSMENT, + MESG_SLEEP_DISRUPTION_SEVERITY_PERIOD, + MESG_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY, + MESG_SKIN_TEMP_OVERNIGHT, + MESG_PAD, + MESGS + } MESG_INDEX; + + typedef enum + { + FILE_ID_MESG_TYPE, + FILE_ID_MESG_MANUFACTURER, + FILE_ID_MESG_PRODUCT, + FILE_ID_MESG_SERIAL_NUMBER, + FILE_ID_MESG_TIME_CREATED, + FILE_ID_MESG_NUMBER, + FILE_ID_MESG_PRODUCT_NAME, + FILE_ID_MESG_FIELDS + } FILE_ID_MESG_FIELD_INDEX; + + typedef enum + { + FILE_ID_MESG_PRODUCT_FIELD_FAVERO_PRODUCT, + FILE_ID_MESG_PRODUCT_FIELD_GARMIN_PRODUCT, + FILE_ID_MESG_PRODUCT_FIELD_SUBFIELDS, + FILE_ID_MESG_PRODUCT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + FILE_ID_MESG_PRODUCT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } FILE_ID_MESG_PRODUCT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + FILE_CREATOR_MESG_SOFTWARE_VERSION, + FILE_CREATOR_MESG_HARDWARE_VERSION, + FILE_CREATOR_MESG_FIELDS + } FILE_CREATOR_MESG_FIELD_INDEX; + + typedef enum + { + TIMESTAMP_CORRELATION_MESG_TIMESTAMP, + TIMESTAMP_CORRELATION_MESG_FRACTIONAL_TIMESTAMP, + TIMESTAMP_CORRELATION_MESG_SYSTEM_TIMESTAMP, + TIMESTAMP_CORRELATION_MESG_FRACTIONAL_SYSTEM_TIMESTAMP, + TIMESTAMP_CORRELATION_MESG_LOCAL_TIMESTAMP, + TIMESTAMP_CORRELATION_MESG_TIMESTAMP_MS, + TIMESTAMP_CORRELATION_MESG_SYSTEM_TIMESTAMP_MS, + TIMESTAMP_CORRELATION_MESG_FIELDS + } TIMESTAMP_CORRELATION_MESG_FIELD_INDEX; + + typedef enum + { + SOFTWARE_MESG_MESSAGE_INDEX, + SOFTWARE_MESG_VERSION, + SOFTWARE_MESG_PART_NUMBER, + SOFTWARE_MESG_FIELDS + } SOFTWARE_MESG_FIELD_INDEX; + + typedef enum + { + SLAVE_DEVICE_MESG_MANUFACTURER, + SLAVE_DEVICE_MESG_PRODUCT, + SLAVE_DEVICE_MESG_FIELDS + } SLAVE_DEVICE_MESG_FIELD_INDEX; + + typedef enum + { + SLAVE_DEVICE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT, + SLAVE_DEVICE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT, + SLAVE_DEVICE_MESG_PRODUCT_FIELD_SUBFIELDS, + SLAVE_DEVICE_MESG_PRODUCT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + SLAVE_DEVICE_MESG_PRODUCT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } SLAVE_DEVICE_MESG_PRODUCT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + CAPABILITIES_MESG_LANGUAGES, + CAPABILITIES_MESG_SPORTS, + CAPABILITIES_MESG_WORKOUTS_SUPPORTED, + CAPABILITIES_MESG_CONNECTIVITY_SUPPORTED, + CAPABILITIES_MESG_FIELDS + } CAPABILITIES_MESG_FIELD_INDEX; + + typedef enum + { + FILE_CAPABILITIES_MESG_MESSAGE_INDEX, + FILE_CAPABILITIES_MESG_TYPE, + FILE_CAPABILITIES_MESG_FLAGS, + FILE_CAPABILITIES_MESG_DIRECTORY, + FILE_CAPABILITIES_MESG_MAX_COUNT, + FILE_CAPABILITIES_MESG_MAX_SIZE, + FILE_CAPABILITIES_MESG_FIELDS + } FILE_CAPABILITIES_MESG_FIELD_INDEX; + + typedef enum + { + MESG_CAPABILITIES_MESG_MESSAGE_INDEX, + MESG_CAPABILITIES_MESG_FILE, + MESG_CAPABILITIES_MESG_MESG_NUM, + MESG_CAPABILITIES_MESG_COUNT_TYPE, + MESG_CAPABILITIES_MESG_COUNT, + MESG_CAPABILITIES_MESG_FIELDS + } MESG_CAPABILITIES_MESG_FIELD_INDEX; + + typedef enum + { + MESG_CAPABILITIES_MESG_COUNT_FIELD_NUM_PER_FILE, + MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE, + MESG_CAPABILITIES_MESG_COUNT_FIELD_MAX_PER_FILE_TYPE, + MESG_CAPABILITIES_MESG_COUNT_FIELD_SUBFIELDS, + MESG_CAPABILITIES_MESG_COUNT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + MESG_CAPABILITIES_MESG_COUNT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } MESG_CAPABILITIES_MESG_COUNT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + FIELD_CAPABILITIES_MESG_MESSAGE_INDEX, + FIELD_CAPABILITIES_MESG_FILE, + FIELD_CAPABILITIES_MESG_MESG_NUM, + FIELD_CAPABILITIES_MESG_FIELD_NUM, + FIELD_CAPABILITIES_MESG_COUNT, + FIELD_CAPABILITIES_MESG_FIELDS + } FIELD_CAPABILITIES_MESG_FIELD_INDEX; + + typedef enum + { + DEVICE_SETTINGS_MESG_ACTIVE_TIME_ZONE, + DEVICE_SETTINGS_MESG_UTC_OFFSET, + DEVICE_SETTINGS_MESG_TIME_OFFSET, + DEVICE_SETTINGS_MESG_TIME_MODE, + DEVICE_SETTINGS_MESG_TIME_ZONE_OFFSET, + DEVICE_SETTINGS_MESG_BACKLIGHT_MODE, + DEVICE_SETTINGS_MESG_ACTIVITY_TRACKER_ENABLED, + DEVICE_SETTINGS_MESG_CLOCK_TIME, + DEVICE_SETTINGS_MESG_PAGES_ENABLED, + DEVICE_SETTINGS_MESG_MOVE_ALERT_ENABLED, + DEVICE_SETTINGS_MESG_DATE_MODE, + DEVICE_SETTINGS_MESG_DISPLAY_ORIENTATION, + DEVICE_SETTINGS_MESG_MOUNTING_SIDE, + DEVICE_SETTINGS_MESG_DEFAULT_PAGE, + DEVICE_SETTINGS_MESG_AUTOSYNC_MIN_STEPS, + DEVICE_SETTINGS_MESG_AUTOSYNC_MIN_TIME, + DEVICE_SETTINGS_MESG_LACTATE_THRESHOLD_AUTODETECT_ENABLED, + DEVICE_SETTINGS_MESG_BLE_AUTO_UPLOAD_ENABLED, + DEVICE_SETTINGS_MESG_AUTO_SYNC_FREQUENCY, + DEVICE_SETTINGS_MESG_AUTO_ACTIVITY_DETECT, + DEVICE_SETTINGS_MESG_NUMBER_OF_SCREENS, + DEVICE_SETTINGS_MESG_SMART_NOTIFICATION_DISPLAY_ORIENTATION, + DEVICE_SETTINGS_MESG_TAP_INTERFACE, + DEVICE_SETTINGS_MESG_TAP_SENSITIVITY, + DEVICE_SETTINGS_MESG_FIELDS + } DEVICE_SETTINGS_MESG_FIELD_INDEX; + + typedef enum + { + USER_PROFILE_MESG_MESSAGE_INDEX, + USER_PROFILE_MESG_FRIENDLY_NAME, + USER_PROFILE_MESG_GENDER, + USER_PROFILE_MESG_AGE, + USER_PROFILE_MESG_HEIGHT, + USER_PROFILE_MESG_WEIGHT, + USER_PROFILE_MESG_LANGUAGE, + USER_PROFILE_MESG_ELEV_SETTING, + USER_PROFILE_MESG_WEIGHT_SETTING, + USER_PROFILE_MESG_RESTING_HEART_RATE, + USER_PROFILE_MESG_DEFAULT_MAX_RUNNING_HEART_RATE, + USER_PROFILE_MESG_DEFAULT_MAX_BIKING_HEART_RATE, + USER_PROFILE_MESG_DEFAULT_MAX_HEART_RATE, + USER_PROFILE_MESG_HR_SETTING, + USER_PROFILE_MESG_SPEED_SETTING, + USER_PROFILE_MESG_DIST_SETTING, + USER_PROFILE_MESG_POWER_SETTING, + USER_PROFILE_MESG_ACTIVITY_CLASS, + USER_PROFILE_MESG_POSITION_SETTING, + USER_PROFILE_MESG_TEMPERATURE_SETTING, + USER_PROFILE_MESG_LOCAL_ID, + USER_PROFILE_MESG_GLOBAL_ID, + USER_PROFILE_MESG_WAKE_TIME, + USER_PROFILE_MESG_SLEEP_TIME, + USER_PROFILE_MESG_HEIGHT_SETTING, + USER_PROFILE_MESG_USER_RUNNING_STEP_LENGTH, + USER_PROFILE_MESG_USER_WALKING_STEP_LENGTH, + USER_PROFILE_MESG_DEPTH_SETTING, + USER_PROFILE_MESG_DIVE_COUNT, + USER_PROFILE_MESG_FIELDS + } USER_PROFILE_MESG_FIELD_INDEX; + + typedef enum + { + HRM_PROFILE_MESG_MESSAGE_INDEX, + HRM_PROFILE_MESG_ENABLED, + HRM_PROFILE_MESG_HRM_ANT_ID, + HRM_PROFILE_MESG_LOG_HRV, + HRM_PROFILE_MESG_HRM_ANT_ID_TRANS_TYPE, + HRM_PROFILE_MESG_FIELDS + } HRM_PROFILE_MESG_FIELD_INDEX; + + typedef enum + { + SDM_PROFILE_MESG_MESSAGE_INDEX, + SDM_PROFILE_MESG_ENABLED, + SDM_PROFILE_MESG_SDM_ANT_ID, + SDM_PROFILE_MESG_SDM_CAL_FACTOR, + SDM_PROFILE_MESG_ODOMETER, + SDM_PROFILE_MESG_SPEED_SOURCE, + SDM_PROFILE_MESG_SDM_ANT_ID_TRANS_TYPE, + SDM_PROFILE_MESG_ODOMETER_ROLLOVER, + SDM_PROFILE_MESG_FIELDS + } SDM_PROFILE_MESG_FIELD_INDEX; + + typedef enum + { + BIKE_PROFILE_MESG_MESSAGE_INDEX, + BIKE_PROFILE_MESG_NAME, + BIKE_PROFILE_MESG_SPORT, + BIKE_PROFILE_MESG_SUB_SPORT, + BIKE_PROFILE_MESG_ODOMETER, + BIKE_PROFILE_MESG_BIKE_SPD_ANT_ID, + BIKE_PROFILE_MESG_BIKE_CAD_ANT_ID, + BIKE_PROFILE_MESG_BIKE_SPDCAD_ANT_ID, + BIKE_PROFILE_MESG_BIKE_POWER_ANT_ID, + BIKE_PROFILE_MESG_CUSTOM_WHEELSIZE, + BIKE_PROFILE_MESG_AUTO_WHEELSIZE, + BIKE_PROFILE_MESG_BIKE_WEIGHT, + BIKE_PROFILE_MESG_POWER_CAL_FACTOR, + BIKE_PROFILE_MESG_AUTO_WHEEL_CAL, + BIKE_PROFILE_MESG_AUTO_POWER_ZERO, + BIKE_PROFILE_MESG_ID, + BIKE_PROFILE_MESG_SPD_ENABLED, + BIKE_PROFILE_MESG_CAD_ENABLED, + BIKE_PROFILE_MESG_SPDCAD_ENABLED, + BIKE_PROFILE_MESG_POWER_ENABLED, + BIKE_PROFILE_MESG_CRANK_LENGTH, + BIKE_PROFILE_MESG_ENABLED, + BIKE_PROFILE_MESG_BIKE_SPD_ANT_ID_TRANS_TYPE, + BIKE_PROFILE_MESG_BIKE_CAD_ANT_ID_TRANS_TYPE, + BIKE_PROFILE_MESG_BIKE_SPDCAD_ANT_ID_TRANS_TYPE, + BIKE_PROFILE_MESG_BIKE_POWER_ANT_ID_TRANS_TYPE, + BIKE_PROFILE_MESG_ODOMETER_ROLLOVER, + BIKE_PROFILE_MESG_FRONT_GEAR_NUM, + BIKE_PROFILE_MESG_FRONT_GEAR, + BIKE_PROFILE_MESG_REAR_GEAR_NUM, + BIKE_PROFILE_MESG_REAR_GEAR, + BIKE_PROFILE_MESG_SHIMANO_DI2_ENABLED, + BIKE_PROFILE_MESG_FIELDS + } BIKE_PROFILE_MESG_FIELD_INDEX; + + typedef enum + { + CONNECTIVITY_MESG_BLUETOOTH_ENABLED, + CONNECTIVITY_MESG_BLUETOOTH_LE_ENABLED, + CONNECTIVITY_MESG_ANT_ENABLED, + CONNECTIVITY_MESG_NAME, + CONNECTIVITY_MESG_LIVE_TRACKING_ENABLED, + CONNECTIVITY_MESG_WEATHER_CONDITIONS_ENABLED, + CONNECTIVITY_MESG_WEATHER_ALERTS_ENABLED, + CONNECTIVITY_MESG_AUTO_ACTIVITY_UPLOAD_ENABLED, + CONNECTIVITY_MESG_COURSE_DOWNLOAD_ENABLED, + CONNECTIVITY_MESG_WORKOUT_DOWNLOAD_ENABLED, + CONNECTIVITY_MESG_GPS_EPHEMERIS_DOWNLOAD_ENABLED, + CONNECTIVITY_MESG_INCIDENT_DETECTION_ENABLED, + CONNECTIVITY_MESG_GROUPTRACK_ENABLED, + CONNECTIVITY_MESG_FIELDS + } CONNECTIVITY_MESG_FIELD_INDEX; + + typedef enum + { + WATCHFACE_SETTINGS_MESG_MESSAGE_INDEX, + WATCHFACE_SETTINGS_MESG_MODE, + WATCHFACE_SETTINGS_MESG_LAYOUT, + WATCHFACE_SETTINGS_MESG_FIELDS + } WATCHFACE_SETTINGS_MESG_FIELD_INDEX; + + typedef enum + { + WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_DIGITAL_LAYOUT, + WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_ANALOG_LAYOUT, + WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_SUBFIELDS, + WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + OHR_SETTINGS_MESG_TIMESTAMP, + OHR_SETTINGS_MESG_ENABLED, + OHR_SETTINGS_MESG_FIELDS + } OHR_SETTINGS_MESG_FIELD_INDEX; + + typedef enum + { + TIME_IN_ZONE_MESG_TIMESTAMP, + TIME_IN_ZONE_MESG_REFERENCE_MESG, + TIME_IN_ZONE_MESG_REFERENCE_INDEX, + TIME_IN_ZONE_MESG_TIME_IN_HR_ZONE, + TIME_IN_ZONE_MESG_TIME_IN_SPEED_ZONE, + TIME_IN_ZONE_MESG_TIME_IN_CADENCE_ZONE, + TIME_IN_ZONE_MESG_TIME_IN_POWER_ZONE, + TIME_IN_ZONE_MESG_HR_ZONE_HIGH_BOUNDARY, + TIME_IN_ZONE_MESG_SPEED_ZONE_HIGH_BOUNDARY, + TIME_IN_ZONE_MESG_CADENCE_ZONE_HIGH_BONDARY, + TIME_IN_ZONE_MESG_POWER_ZONE_HIGH_BOUNDARY, + TIME_IN_ZONE_MESG_HR_CALC_TYPE, + TIME_IN_ZONE_MESG_MAX_HEART_RATE, + TIME_IN_ZONE_MESG_RESTING_HEART_RATE, + TIME_IN_ZONE_MESG_THRESHOLD_HEART_RATE, + TIME_IN_ZONE_MESG_PWR_CALC_TYPE, + TIME_IN_ZONE_MESG_FUNCTIONAL_THRESHOLD_POWER, + TIME_IN_ZONE_MESG_FIELDS + } TIME_IN_ZONE_MESG_FIELD_INDEX; + + typedef enum + { + ZONES_TARGET_MESG_MAX_HEART_RATE, + ZONES_TARGET_MESG_THRESHOLD_HEART_RATE, + ZONES_TARGET_MESG_FUNCTIONAL_THRESHOLD_POWER, + ZONES_TARGET_MESG_HR_CALC_TYPE, + ZONES_TARGET_MESG_PWR_CALC_TYPE, + ZONES_TARGET_MESG_FIELDS + } ZONES_TARGET_MESG_FIELD_INDEX; + + typedef enum + { + SPORT_MESG_SPORT, + SPORT_MESG_SUB_SPORT, + SPORT_MESG_NAME, + SPORT_MESG_FIELDS + } SPORT_MESG_FIELD_INDEX; + + typedef enum + { + HR_ZONE_MESG_MESSAGE_INDEX, + HR_ZONE_MESG_HIGH_BPM, + HR_ZONE_MESG_NAME, + HR_ZONE_MESG_FIELDS + } HR_ZONE_MESG_FIELD_INDEX; + + typedef enum + { + SPEED_ZONE_MESG_MESSAGE_INDEX, + SPEED_ZONE_MESG_HIGH_VALUE, + SPEED_ZONE_MESG_NAME, + SPEED_ZONE_MESG_FIELDS + } SPEED_ZONE_MESG_FIELD_INDEX; + + typedef enum + { + CADENCE_ZONE_MESG_MESSAGE_INDEX, + CADENCE_ZONE_MESG_HIGH_VALUE, + CADENCE_ZONE_MESG_NAME, + CADENCE_ZONE_MESG_FIELDS + } CADENCE_ZONE_MESG_FIELD_INDEX; + + typedef enum + { + POWER_ZONE_MESG_MESSAGE_INDEX, + POWER_ZONE_MESG_HIGH_VALUE, + POWER_ZONE_MESG_NAME, + POWER_ZONE_MESG_FIELDS + } POWER_ZONE_MESG_FIELD_INDEX; + + typedef enum + { + MET_ZONE_MESG_MESSAGE_INDEX, + MET_ZONE_MESG_HIGH_BPM, + MET_ZONE_MESG_CALORIES, + MET_ZONE_MESG_FAT_CALORIES, + MET_ZONE_MESG_FIELDS + } MET_ZONE_MESG_FIELD_INDEX; + + typedef enum + { + TRAINING_SETTINGS_MESG_TARGET_DISTANCE, + TRAINING_SETTINGS_MESG_TARGET_SPEED, + TRAINING_SETTINGS_MESG_TARGET_TIME, + TRAINING_SETTINGS_MESG_PRECISE_TARGET_SPEED, + TRAINING_SETTINGS_MESG_FIELDS + } TRAINING_SETTINGS_MESG_FIELD_INDEX; + + typedef enum + { + DIVE_SETTINGS_MESG_TIMESTAMP, + DIVE_SETTINGS_MESG_MESSAGE_INDEX, + DIVE_SETTINGS_MESG_NAME, + DIVE_SETTINGS_MESG_MODEL, + DIVE_SETTINGS_MESG_GF_LOW, + DIVE_SETTINGS_MESG_GF_HIGH, + DIVE_SETTINGS_MESG_WATER_TYPE, + DIVE_SETTINGS_MESG_WATER_DENSITY, + DIVE_SETTINGS_MESG_PO2_WARN, + DIVE_SETTINGS_MESG_PO2_CRITICAL, + DIVE_SETTINGS_MESG_PO2_DECO, + DIVE_SETTINGS_MESG_SAFETY_STOP_ENABLED, + DIVE_SETTINGS_MESG_BOTTOM_DEPTH, + DIVE_SETTINGS_MESG_BOTTOM_TIME, + DIVE_SETTINGS_MESG_APNEA_COUNTDOWN_ENABLED, + DIVE_SETTINGS_MESG_APNEA_COUNTDOWN_TIME, + DIVE_SETTINGS_MESG_BACKLIGHT_MODE, + DIVE_SETTINGS_MESG_BACKLIGHT_BRIGHTNESS, + DIVE_SETTINGS_MESG_BACKLIGHT_TIMEOUT, + DIVE_SETTINGS_MESG_REPEAT_DIVE_INTERVAL, + DIVE_SETTINGS_MESG_SAFETY_STOP_TIME, + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_TYPE, + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE, + DIVE_SETTINGS_MESG_TRAVEL_GAS, + DIVE_SETTINGS_MESG_CCR_LOW_SETPOINT_SWITCH_MODE, + DIVE_SETTINGS_MESG_CCR_LOW_SETPOINT, + DIVE_SETTINGS_MESG_CCR_LOW_SETPOINT_DEPTH, + DIVE_SETTINGS_MESG_CCR_HIGH_SETPOINT_SWITCH_MODE, + DIVE_SETTINGS_MESG_CCR_HIGH_SETPOINT, + DIVE_SETTINGS_MESG_CCR_HIGH_SETPOINT_DEPTH, + DIVE_SETTINGS_MESG_GAS_CONSUMPTION_DISPLAY, + DIVE_SETTINGS_MESG_UP_KEY_ENABLED, + DIVE_SETTINGS_MESG_DIVE_SOUNDS, + DIVE_SETTINGS_MESG_LAST_STOP_MULTIPLE, + DIVE_SETTINGS_MESG_NO_FLY_TIME_MODE, + DIVE_SETTINGS_MESG_FIELDS + } DIVE_SETTINGS_MESG_FIELD_INDEX; + + typedef enum + { + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_ANTPLUS_DEVICE_TYPE, + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_HEART_RATE_LOCAL_DEVICE_TYPE, + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_SUBFIELDS, + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } DIVE_SETTINGS_MESG_HEART_RATE_SOURCE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + DIVE_ALARM_MESG_MESSAGE_INDEX, + DIVE_ALARM_MESG_DEPTH, + DIVE_ALARM_MESG_TIME, + DIVE_ALARM_MESG_ENABLED, + DIVE_ALARM_MESG_ALARM_TYPE, + DIVE_ALARM_MESG_SOUND, + DIVE_ALARM_MESG_DIVE_TYPES, + DIVE_ALARM_MESG_ID, + DIVE_ALARM_MESG_POPUP_ENABLED, + DIVE_ALARM_MESG_TRIGGER_ON_DESCENT, + DIVE_ALARM_MESG_TRIGGER_ON_ASCENT, + DIVE_ALARM_MESG_REPEATING, + DIVE_ALARM_MESG_SPEED, + DIVE_ALARM_MESG_FIELDS + } DIVE_ALARM_MESG_FIELD_INDEX; + + typedef enum + { + DIVE_APNEA_ALARM_MESG_MESSAGE_INDEX, + DIVE_APNEA_ALARM_MESG_DEPTH, + DIVE_APNEA_ALARM_MESG_TIME, + DIVE_APNEA_ALARM_MESG_ENABLED, + DIVE_APNEA_ALARM_MESG_ALARM_TYPE, + DIVE_APNEA_ALARM_MESG_SOUND, + DIVE_APNEA_ALARM_MESG_DIVE_TYPES, + DIVE_APNEA_ALARM_MESG_ID, + DIVE_APNEA_ALARM_MESG_POPUP_ENABLED, + DIVE_APNEA_ALARM_MESG_TRIGGER_ON_DESCENT, + DIVE_APNEA_ALARM_MESG_TRIGGER_ON_ASCENT, + DIVE_APNEA_ALARM_MESG_REPEATING, + DIVE_APNEA_ALARM_MESG_SPEED, + DIVE_APNEA_ALARM_MESG_FIELDS + } DIVE_APNEA_ALARM_MESG_FIELD_INDEX; + + typedef enum + { + DIVE_GAS_MESG_MESSAGE_INDEX, + DIVE_GAS_MESG_HELIUM_CONTENT, + DIVE_GAS_MESG_OXYGEN_CONTENT, + DIVE_GAS_MESG_STATUS, + DIVE_GAS_MESG_MODE, + DIVE_GAS_MESG_FIELDS + } DIVE_GAS_MESG_FIELD_INDEX; + + typedef enum + { + GOAL_MESG_MESSAGE_INDEX, + GOAL_MESG_SPORT, + GOAL_MESG_SUB_SPORT, + GOAL_MESG_START_DATE, + GOAL_MESG_END_DATE, + GOAL_MESG_TYPE, + GOAL_MESG_VALUE, + GOAL_MESG_REPEAT, + GOAL_MESG_TARGET_VALUE, + GOAL_MESG_RECURRENCE, + GOAL_MESG_RECURRENCE_VALUE, + GOAL_MESG_ENABLED, + GOAL_MESG_SOURCE, + GOAL_MESG_FIELDS + } GOAL_MESG_FIELD_INDEX; + + typedef enum + { + ACTIVITY_MESG_TIMESTAMP, + ACTIVITY_MESG_TOTAL_TIMER_TIME, + ACTIVITY_MESG_NUM_SESSIONS, + ACTIVITY_MESG_TYPE, + ACTIVITY_MESG_EVENT, + ACTIVITY_MESG_EVENT_TYPE, + ACTIVITY_MESG_LOCAL_TIMESTAMP, + ACTIVITY_MESG_EVENT_GROUP, + ACTIVITY_MESG_FIELDS + } ACTIVITY_MESG_FIELD_INDEX; + + typedef enum + { + SESSION_MESG_MESSAGE_INDEX, + SESSION_MESG_TIMESTAMP, + SESSION_MESG_EVENT, + SESSION_MESG_EVENT_TYPE, + SESSION_MESG_START_TIME, + SESSION_MESG_START_POSITION_LAT, + SESSION_MESG_START_POSITION_LONG, + SESSION_MESG_SPORT, + SESSION_MESG_SUB_SPORT, + SESSION_MESG_TOTAL_ELAPSED_TIME, + SESSION_MESG_TOTAL_TIMER_TIME, + SESSION_MESG_TOTAL_DISTANCE, + SESSION_MESG_TOTAL_CYCLES, + SESSION_MESG_TOTAL_CALORIES, + SESSION_MESG_TOTAL_FAT_CALORIES, + SESSION_MESG_AVG_SPEED, + SESSION_MESG_MAX_SPEED, + SESSION_MESG_AVG_HEART_RATE, + SESSION_MESG_MAX_HEART_RATE, + SESSION_MESG_AVG_CADENCE, + SESSION_MESG_MAX_CADENCE, + SESSION_MESG_AVG_POWER, + SESSION_MESG_MAX_POWER, + SESSION_MESG_TOTAL_ASCENT, + SESSION_MESG_TOTAL_DESCENT, + SESSION_MESG_TOTAL_TRAINING_EFFECT, + SESSION_MESG_FIRST_LAP_INDEX, + SESSION_MESG_NUM_LAPS, + SESSION_MESG_EVENT_GROUP, + SESSION_MESG_TRIGGER, + SESSION_MESG_NEC_LAT, + SESSION_MESG_NEC_LONG, + SESSION_MESG_SWC_LAT, + SESSION_MESG_SWC_LONG, + SESSION_MESG_NUM_LENGTHS, + SESSION_MESG_NORMALIZED_POWER, + SESSION_MESG_TRAINING_STRESS_SCORE, + SESSION_MESG_INTENSITY_FACTOR, + SESSION_MESG_LEFT_RIGHT_BALANCE, + SESSION_MESG_END_POSITION_LAT, + SESSION_MESG_END_POSITION_LONG, + SESSION_MESG_AVG_STROKE_COUNT, + SESSION_MESG_AVG_STROKE_DISTANCE, + SESSION_MESG_SWIM_STROKE, + SESSION_MESG_POOL_LENGTH, + SESSION_MESG_THRESHOLD_POWER, + SESSION_MESG_POOL_LENGTH_UNIT, + SESSION_MESG_NUM_ACTIVE_LENGTHS, + SESSION_MESG_TOTAL_WORK, + SESSION_MESG_AVG_ALTITUDE, + SESSION_MESG_MAX_ALTITUDE, + SESSION_MESG_GPS_ACCURACY, + SESSION_MESG_AVG_GRADE, + SESSION_MESG_AVG_POS_GRADE, + SESSION_MESG_AVG_NEG_GRADE, + SESSION_MESG_MAX_POS_GRADE, + SESSION_MESG_MAX_NEG_GRADE, + SESSION_MESG_AVG_TEMPERATURE, + SESSION_MESG_MAX_TEMPERATURE, + SESSION_MESG_TOTAL_MOVING_TIME, + SESSION_MESG_AVG_POS_VERTICAL_SPEED, + SESSION_MESG_AVG_NEG_VERTICAL_SPEED, + SESSION_MESG_MAX_POS_VERTICAL_SPEED, + SESSION_MESG_MAX_NEG_VERTICAL_SPEED, + SESSION_MESG_MIN_HEART_RATE, + SESSION_MESG_TIME_IN_HR_ZONE, + SESSION_MESG_TIME_IN_SPEED_ZONE, + SESSION_MESG_TIME_IN_CADENCE_ZONE, + SESSION_MESG_TIME_IN_POWER_ZONE, + SESSION_MESG_AVG_LAP_TIME, + SESSION_MESG_BEST_LAP_INDEX, + SESSION_MESG_MIN_ALTITUDE, + SESSION_MESG_PLAYER_SCORE, + SESSION_MESG_OPPONENT_SCORE, + SESSION_MESG_OPPONENT_NAME, + SESSION_MESG_STROKE_COUNT, + SESSION_MESG_ZONE_COUNT, + SESSION_MESG_MAX_BALL_SPEED, + SESSION_MESG_AVG_BALL_SPEED, + SESSION_MESG_AVG_VERTICAL_OSCILLATION, + SESSION_MESG_AVG_STANCE_TIME_PERCENT, + SESSION_MESG_AVG_STANCE_TIME, + SESSION_MESG_AVG_FRACTIONAL_CADENCE, + SESSION_MESG_MAX_FRACTIONAL_CADENCE, + SESSION_MESG_TOTAL_FRACTIONAL_CYCLES, + SESSION_MESG_AVG_TOTAL_HEMOGLOBIN_CONC, + SESSION_MESG_MIN_TOTAL_HEMOGLOBIN_CONC, + SESSION_MESG_MAX_TOTAL_HEMOGLOBIN_CONC, + SESSION_MESG_AVG_SATURATED_HEMOGLOBIN_PERCENT, + SESSION_MESG_MIN_SATURATED_HEMOGLOBIN_PERCENT, + SESSION_MESG_MAX_SATURATED_HEMOGLOBIN_PERCENT, + SESSION_MESG_AVG_LEFT_TORQUE_EFFECTIVENESS, + SESSION_MESG_AVG_RIGHT_TORQUE_EFFECTIVENESS, + SESSION_MESG_AVG_LEFT_PEDAL_SMOOTHNESS, + SESSION_MESG_AVG_RIGHT_PEDAL_SMOOTHNESS, + SESSION_MESG_AVG_COMBINED_PEDAL_SMOOTHNESS, + SESSION_MESG_SPORT_PROFILE_NAME, + SESSION_MESG_SPORT_INDEX, + SESSION_MESG_TIME_STANDING, + SESSION_MESG_STAND_COUNT, + SESSION_MESG_AVG_LEFT_PCO, + SESSION_MESG_AVG_RIGHT_PCO, + SESSION_MESG_AVG_LEFT_POWER_PHASE, + SESSION_MESG_AVG_LEFT_POWER_PHASE_PEAK, + SESSION_MESG_AVG_RIGHT_POWER_PHASE, + SESSION_MESG_AVG_RIGHT_POWER_PHASE_PEAK, + SESSION_MESG_AVG_POWER_POSITION, + SESSION_MESG_MAX_POWER_POSITION, + SESSION_MESG_AVG_CADENCE_POSITION, + SESSION_MESG_MAX_CADENCE_POSITION, + SESSION_MESG_ENHANCED_AVG_SPEED, + SESSION_MESG_ENHANCED_MAX_SPEED, + SESSION_MESG_ENHANCED_AVG_ALTITUDE, + SESSION_MESG_ENHANCED_MIN_ALTITUDE, + SESSION_MESG_ENHANCED_MAX_ALTITUDE, + SESSION_MESG_AVG_LEV_MOTOR_POWER, + SESSION_MESG_MAX_LEV_MOTOR_POWER, + SESSION_MESG_LEV_BATTERY_CONSUMPTION, + SESSION_MESG_AVG_VERTICAL_RATIO, + SESSION_MESG_AVG_STANCE_TIME_BALANCE, + SESSION_MESG_AVG_STEP_LENGTH, + SESSION_MESG_TOTAL_ANAEROBIC_TRAINING_EFFECT, + SESSION_MESG_AVG_VAM, + SESSION_MESG_AVG_DEPTH, + SESSION_MESG_MAX_DEPTH, + SESSION_MESG_SURFACE_INTERVAL, + SESSION_MESG_START_CNS, + SESSION_MESG_END_CNS, + SESSION_MESG_START_N2, + SESSION_MESG_END_N2, + SESSION_MESG_AVG_RESPIRATION_RATE, + SESSION_MESG_MAX_RESPIRATION_RATE, + SESSION_MESG_MIN_RESPIRATION_RATE, + SESSION_MESG_MIN_TEMPERATURE, + SESSION_MESG_O2_TOXICITY, + SESSION_MESG_DIVE_NUMBER, + SESSION_MESG_TRAINING_LOAD_PEAK, + SESSION_MESG_ENHANCED_AVG_RESPIRATION_RATE, + SESSION_MESG_ENHANCED_MAX_RESPIRATION_RATE, + SESSION_MESG_ENHANCED_MIN_RESPIRATION_RATE, + SESSION_MESG_TOTAL_GRIT, + SESSION_MESG_TOTAL_FLOW, + SESSION_MESG_JUMP_COUNT, + SESSION_MESG_AVG_GRIT, + SESSION_MESG_AVG_FLOW, + SESSION_MESG_WORKOUT_FEEL, + SESSION_MESG_WORKOUT_RPE, + SESSION_MESG_AVG_SPO2, + SESSION_MESG_AVG_STRESS, + SESSION_MESG_SDRR_HRV, + SESSION_MESG_RMSSD_HRV, + SESSION_MESG_TOTAL_FRACTIONAL_ASCENT, + SESSION_MESG_TOTAL_FRACTIONAL_DESCENT, + SESSION_MESG_AVG_CORE_TEMPERATURE, + SESSION_MESG_MIN_CORE_TEMPERATURE, + SESSION_MESG_MAX_CORE_TEMPERATURE, + SESSION_MESG_FIELDS + } SESSION_MESG_FIELD_INDEX; + + typedef enum + { + SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES, + SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES, + SESSION_MESG_TOTAL_CYCLES_FIELD_SUBFIELDS, + SESSION_MESG_TOTAL_CYCLES_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + SESSION_MESG_TOTAL_CYCLES_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } SESSION_MESG_TOTAL_CYCLES_FIELD_SUBFIELD_INDEX; + + typedef enum + { + SESSION_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE, + SESSION_MESG_AVG_CADENCE_FIELD_SUBFIELDS, + SESSION_MESG_AVG_CADENCE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + SESSION_MESG_AVG_CADENCE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } SESSION_MESG_AVG_CADENCE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + SESSION_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE, + SESSION_MESG_MAX_CADENCE_FIELD_SUBFIELDS, + SESSION_MESG_MAX_CADENCE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + SESSION_MESG_MAX_CADENCE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } SESSION_MESG_MAX_CADENCE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + LAP_MESG_MESSAGE_INDEX, + LAP_MESG_TIMESTAMP, + LAP_MESG_EVENT, + LAP_MESG_EVENT_TYPE, + LAP_MESG_START_TIME, + LAP_MESG_START_POSITION_LAT, + LAP_MESG_START_POSITION_LONG, + LAP_MESG_END_POSITION_LAT, + LAP_MESG_END_POSITION_LONG, + LAP_MESG_TOTAL_ELAPSED_TIME, + LAP_MESG_TOTAL_TIMER_TIME, + LAP_MESG_TOTAL_DISTANCE, + LAP_MESG_TOTAL_CYCLES, + LAP_MESG_TOTAL_CALORIES, + LAP_MESG_TOTAL_FAT_CALORIES, + LAP_MESG_AVG_SPEED, + LAP_MESG_MAX_SPEED, + LAP_MESG_AVG_HEART_RATE, + LAP_MESG_MAX_HEART_RATE, + LAP_MESG_AVG_CADENCE, + LAP_MESG_MAX_CADENCE, + LAP_MESG_AVG_POWER, + LAP_MESG_MAX_POWER, + LAP_MESG_TOTAL_ASCENT, + LAP_MESG_TOTAL_DESCENT, + LAP_MESG_INTENSITY, + LAP_MESG_LAP_TRIGGER, + LAP_MESG_SPORT, + LAP_MESG_EVENT_GROUP, + LAP_MESG_NUM_LENGTHS, + LAP_MESG_NORMALIZED_POWER, + LAP_MESG_LEFT_RIGHT_BALANCE, + LAP_MESG_FIRST_LENGTH_INDEX, + LAP_MESG_AVG_STROKE_DISTANCE, + LAP_MESG_SWIM_STROKE, + LAP_MESG_SUB_SPORT, + LAP_MESG_NUM_ACTIVE_LENGTHS, + LAP_MESG_TOTAL_WORK, + LAP_MESG_AVG_ALTITUDE, + LAP_MESG_MAX_ALTITUDE, + LAP_MESG_GPS_ACCURACY, + LAP_MESG_AVG_GRADE, + LAP_MESG_AVG_POS_GRADE, + LAP_MESG_AVG_NEG_GRADE, + LAP_MESG_MAX_POS_GRADE, + LAP_MESG_MAX_NEG_GRADE, + LAP_MESG_AVG_TEMPERATURE, + LAP_MESG_MAX_TEMPERATURE, + LAP_MESG_TOTAL_MOVING_TIME, + LAP_MESG_AVG_POS_VERTICAL_SPEED, + LAP_MESG_AVG_NEG_VERTICAL_SPEED, + LAP_MESG_MAX_POS_VERTICAL_SPEED, + LAP_MESG_MAX_NEG_VERTICAL_SPEED, + LAP_MESG_TIME_IN_HR_ZONE, + LAP_MESG_TIME_IN_SPEED_ZONE, + LAP_MESG_TIME_IN_CADENCE_ZONE, + LAP_MESG_TIME_IN_POWER_ZONE, + LAP_MESG_REPETITION_NUM, + LAP_MESG_MIN_ALTITUDE, + LAP_MESG_MIN_HEART_RATE, + LAP_MESG_WKT_STEP_INDEX, + LAP_MESG_OPPONENT_SCORE, + LAP_MESG_STROKE_COUNT, + LAP_MESG_ZONE_COUNT, + LAP_MESG_AVG_VERTICAL_OSCILLATION, + LAP_MESG_AVG_STANCE_TIME_PERCENT, + LAP_MESG_AVG_STANCE_TIME, + LAP_MESG_AVG_FRACTIONAL_CADENCE, + LAP_MESG_MAX_FRACTIONAL_CADENCE, + LAP_MESG_TOTAL_FRACTIONAL_CYCLES, + LAP_MESG_PLAYER_SCORE, + LAP_MESG_AVG_TOTAL_HEMOGLOBIN_CONC, + LAP_MESG_MIN_TOTAL_HEMOGLOBIN_CONC, + LAP_MESG_MAX_TOTAL_HEMOGLOBIN_CONC, + LAP_MESG_AVG_SATURATED_HEMOGLOBIN_PERCENT, + LAP_MESG_MIN_SATURATED_HEMOGLOBIN_PERCENT, + LAP_MESG_MAX_SATURATED_HEMOGLOBIN_PERCENT, + LAP_MESG_AVG_LEFT_TORQUE_EFFECTIVENESS, + LAP_MESG_AVG_RIGHT_TORQUE_EFFECTIVENESS, + LAP_MESG_AVG_LEFT_PEDAL_SMOOTHNESS, + LAP_MESG_AVG_RIGHT_PEDAL_SMOOTHNESS, + LAP_MESG_AVG_COMBINED_PEDAL_SMOOTHNESS, + LAP_MESG_TIME_STANDING, + LAP_MESG_STAND_COUNT, + LAP_MESG_AVG_LEFT_PCO, + LAP_MESG_AVG_RIGHT_PCO, + LAP_MESG_AVG_LEFT_POWER_PHASE, + LAP_MESG_AVG_LEFT_POWER_PHASE_PEAK, + LAP_MESG_AVG_RIGHT_POWER_PHASE, + LAP_MESG_AVG_RIGHT_POWER_PHASE_PEAK, + LAP_MESG_AVG_POWER_POSITION, + LAP_MESG_MAX_POWER_POSITION, + LAP_MESG_AVG_CADENCE_POSITION, + LAP_MESG_MAX_CADENCE_POSITION, + LAP_MESG_ENHANCED_AVG_SPEED, + LAP_MESG_ENHANCED_MAX_SPEED, + LAP_MESG_ENHANCED_AVG_ALTITUDE, + LAP_MESG_ENHANCED_MIN_ALTITUDE, + LAP_MESG_ENHANCED_MAX_ALTITUDE, + LAP_MESG_AVG_LEV_MOTOR_POWER, + LAP_MESG_MAX_LEV_MOTOR_POWER, + LAP_MESG_LEV_BATTERY_CONSUMPTION, + LAP_MESG_AVG_VERTICAL_RATIO, + LAP_MESG_AVG_STANCE_TIME_BALANCE, + LAP_MESG_AVG_STEP_LENGTH, + LAP_MESG_AVG_VAM, + LAP_MESG_AVG_DEPTH, + LAP_MESG_MAX_DEPTH, + LAP_MESG_MIN_TEMPERATURE, + LAP_MESG_ENHANCED_AVG_RESPIRATION_RATE, + LAP_MESG_ENHANCED_MAX_RESPIRATION_RATE, + LAP_MESG_AVG_RESPIRATION_RATE, + LAP_MESG_MAX_RESPIRATION_RATE, + LAP_MESG_TOTAL_GRIT, + LAP_MESG_TOTAL_FLOW, + LAP_MESG_JUMP_COUNT, + LAP_MESG_AVG_GRIT, + LAP_MESG_AVG_FLOW, + LAP_MESG_TOTAL_FRACTIONAL_ASCENT, + LAP_MESG_TOTAL_FRACTIONAL_DESCENT, + LAP_MESG_AVG_CORE_TEMPERATURE, + LAP_MESG_MIN_CORE_TEMPERATURE, + LAP_MESG_MAX_CORE_TEMPERATURE, + LAP_MESG_FIELDS + } LAP_MESG_FIELD_INDEX; + + typedef enum + { + LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES, + LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES, + LAP_MESG_TOTAL_CYCLES_FIELD_SUBFIELDS, + LAP_MESG_TOTAL_CYCLES_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + LAP_MESG_TOTAL_CYCLES_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } LAP_MESG_TOTAL_CYCLES_FIELD_SUBFIELD_INDEX; + + typedef enum + { + LAP_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE, + LAP_MESG_AVG_CADENCE_FIELD_SUBFIELDS, + LAP_MESG_AVG_CADENCE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + LAP_MESG_AVG_CADENCE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } LAP_MESG_AVG_CADENCE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + LAP_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE, + LAP_MESG_MAX_CADENCE_FIELD_SUBFIELDS, + LAP_MESG_MAX_CADENCE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + LAP_MESG_MAX_CADENCE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } LAP_MESG_MAX_CADENCE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + LENGTH_MESG_MESSAGE_INDEX, + LENGTH_MESG_TIMESTAMP, + LENGTH_MESG_EVENT, + LENGTH_MESG_EVENT_TYPE, + LENGTH_MESG_START_TIME, + LENGTH_MESG_TOTAL_ELAPSED_TIME, + LENGTH_MESG_TOTAL_TIMER_TIME, + LENGTH_MESG_TOTAL_STROKES, + LENGTH_MESG_AVG_SPEED, + LENGTH_MESG_SWIM_STROKE, + LENGTH_MESG_AVG_SWIMMING_CADENCE, + LENGTH_MESG_EVENT_GROUP, + LENGTH_MESG_TOTAL_CALORIES, + LENGTH_MESG_LENGTH_TYPE, + LENGTH_MESG_PLAYER_SCORE, + LENGTH_MESG_OPPONENT_SCORE, + LENGTH_MESG_STROKE_COUNT, + LENGTH_MESG_ZONE_COUNT, + LENGTH_MESG_ENHANCED_AVG_RESPIRATION_RATE, + LENGTH_MESG_ENHANCED_MAX_RESPIRATION_RATE, + LENGTH_MESG_AVG_RESPIRATION_RATE, + LENGTH_MESG_MAX_RESPIRATION_RATE, + LENGTH_MESG_FIELDS + } LENGTH_MESG_FIELD_INDEX; + + typedef enum + { + RECORD_MESG_TIMESTAMP, + RECORD_MESG_POSITION_LAT, + RECORD_MESG_POSITION_LONG, + RECORD_MESG_ALTITUDE, + RECORD_MESG_HEART_RATE, + RECORD_MESG_CADENCE, + RECORD_MESG_DISTANCE, + RECORD_MESG_SPEED, + RECORD_MESG_POWER, + RECORD_MESG_COMPRESSED_SPEED_DISTANCE, + RECORD_MESG_GRADE, + RECORD_MESG_RESISTANCE, + RECORD_MESG_TIME_FROM_COURSE, + RECORD_MESG_CYCLE_LENGTH, + RECORD_MESG_TEMPERATURE, + RECORD_MESG_SPEED_1S, + RECORD_MESG_CYCLES, + RECORD_MESG_TOTAL_CYCLES, + RECORD_MESG_COMPRESSED_ACCUMULATED_POWER, + RECORD_MESG_ACCUMULATED_POWER, + RECORD_MESG_LEFT_RIGHT_BALANCE, + RECORD_MESG_GPS_ACCURACY, + RECORD_MESG_VERTICAL_SPEED, + RECORD_MESG_CALORIES, + RECORD_MESG_VERTICAL_OSCILLATION, + RECORD_MESG_STANCE_TIME_PERCENT, + RECORD_MESG_STANCE_TIME, + RECORD_MESG_ACTIVITY_TYPE, + RECORD_MESG_LEFT_TORQUE_EFFECTIVENESS, + RECORD_MESG_RIGHT_TORQUE_EFFECTIVENESS, + RECORD_MESG_LEFT_PEDAL_SMOOTHNESS, + RECORD_MESG_RIGHT_PEDAL_SMOOTHNESS, + RECORD_MESG_COMBINED_PEDAL_SMOOTHNESS, + RECORD_MESG_TIME128, + RECORD_MESG_STROKE_TYPE, + RECORD_MESG_ZONE, + RECORD_MESG_BALL_SPEED, + RECORD_MESG_CADENCE256, + RECORD_MESG_FRACTIONAL_CADENCE, + RECORD_MESG_TOTAL_HEMOGLOBIN_CONC, + RECORD_MESG_TOTAL_HEMOGLOBIN_CONC_MIN, + RECORD_MESG_TOTAL_HEMOGLOBIN_CONC_MAX, + RECORD_MESG_SATURATED_HEMOGLOBIN_PERCENT, + RECORD_MESG_SATURATED_HEMOGLOBIN_PERCENT_MIN, + RECORD_MESG_SATURATED_HEMOGLOBIN_PERCENT_MAX, + RECORD_MESG_DEVICE_INDEX, + RECORD_MESG_LEFT_PCO, + RECORD_MESG_RIGHT_PCO, + RECORD_MESG_LEFT_POWER_PHASE, + RECORD_MESG_LEFT_POWER_PHASE_PEAK, + RECORD_MESG_RIGHT_POWER_PHASE, + RECORD_MESG_RIGHT_POWER_PHASE_PEAK, + RECORD_MESG_ENHANCED_SPEED, + RECORD_MESG_ENHANCED_ALTITUDE, + RECORD_MESG_BATTERY_SOC, + RECORD_MESG_MOTOR_POWER, + RECORD_MESG_VERTICAL_RATIO, + RECORD_MESG_STANCE_TIME_BALANCE, + RECORD_MESG_STEP_LENGTH, + RECORD_MESG_CYCLE_LENGTH16, + RECORD_MESG_ABSOLUTE_PRESSURE, + RECORD_MESG_DEPTH, + RECORD_MESG_NEXT_STOP_DEPTH, + RECORD_MESG_NEXT_STOP_TIME, + RECORD_MESG_TIME_TO_SURFACE, + RECORD_MESG_NDL_TIME, + RECORD_MESG_CNS_LOAD, + RECORD_MESG_N2_LOAD, + RECORD_MESG_RESPIRATION_RATE, + RECORD_MESG_ENHANCED_RESPIRATION_RATE, + RECORD_MESG_GRIT, + RECORD_MESG_FLOW, + RECORD_MESG_CURRENT_STRESS, + RECORD_MESG_EBIKE_TRAVEL_RANGE, + RECORD_MESG_EBIKE_BATTERY_LEVEL, + RECORD_MESG_EBIKE_ASSIST_MODE, + RECORD_MESG_EBIKE_ASSIST_LEVEL_PERCENT, + RECORD_MESG_AIR_TIME_REMAINING, + RECORD_MESG_PRESSURE_SAC, + RECORD_MESG_VOLUME_SAC, + RECORD_MESG_RMV, + RECORD_MESG_ASCENT_RATE, + RECORD_MESG_PO2, + RECORD_MESG_CORE_TEMPERATURE, + RECORD_MESG_FIELDS + } RECORD_MESG_FIELD_INDEX; + + typedef enum + { + EVENT_MESG_TIMESTAMP, + EVENT_MESG_EVENT, + EVENT_MESG_EVENT_TYPE, + EVENT_MESG_DATA16, + EVENT_MESG_DATA, + EVENT_MESG_EVENT_GROUP, + EVENT_MESG_SCORE, + EVENT_MESG_OPPONENT_SCORE, + EVENT_MESG_FRONT_GEAR_NUM, + EVENT_MESG_FRONT_GEAR, + EVENT_MESG_REAR_GEAR_NUM, + EVENT_MESG_REAR_GEAR, + EVENT_MESG_DEVICE_INDEX, + EVENT_MESG_ACTIVITY_TYPE, + EVENT_MESG_START_TIMESTAMP, + EVENT_MESG_RADAR_THREAT_LEVEL_MAX, + EVENT_MESG_RADAR_THREAT_COUNT, + EVENT_MESG_RADAR_THREAT_AVG_APPROACH_SPEED, + EVENT_MESG_RADAR_THREAT_MAX_APPROACH_SPEED, + EVENT_MESG_FIELDS + } EVENT_MESG_FIELD_INDEX; + + typedef enum + { + EVENT_MESG_DATA_FIELD_TIMER_TRIGGER, + EVENT_MESG_DATA_FIELD_COURSE_POINT_INDEX, + EVENT_MESG_DATA_FIELD_BATTERY_LEVEL, + EVENT_MESG_DATA_FIELD_VIRTUAL_PARTNER_SPEED, + EVENT_MESG_DATA_FIELD_HR_HIGH_ALERT, + EVENT_MESG_DATA_FIELD_HR_LOW_ALERT, + EVENT_MESG_DATA_FIELD_SPEED_HIGH_ALERT, + EVENT_MESG_DATA_FIELD_SPEED_LOW_ALERT, + EVENT_MESG_DATA_FIELD_CAD_HIGH_ALERT, + EVENT_MESG_DATA_FIELD_CAD_LOW_ALERT, + EVENT_MESG_DATA_FIELD_POWER_HIGH_ALERT, + EVENT_MESG_DATA_FIELD_POWER_LOW_ALERT, + EVENT_MESG_DATA_FIELD_TIME_DURATION_ALERT, + EVENT_MESG_DATA_FIELD_DISTANCE_DURATION_ALERT, + EVENT_MESG_DATA_FIELD_CALORIE_DURATION_ALERT, + EVENT_MESG_DATA_FIELD_FITNESS_EQUIPMENT_STATE, + EVENT_MESG_DATA_FIELD_SPORT_POINT, + EVENT_MESG_DATA_FIELD_GEAR_CHANGE_DATA, + EVENT_MESG_DATA_FIELD_RIDER_POSITION, + EVENT_MESG_DATA_FIELD_COMM_TIMEOUT, + EVENT_MESG_DATA_FIELD_DIVE_ALERT, + EVENT_MESG_DATA_FIELD_AUTO_ACTIVITY_DETECT_DURATION, + EVENT_MESG_DATA_FIELD_RADAR_THREAT_ALERT, + EVENT_MESG_DATA_FIELD_SUBFIELDS, + EVENT_MESG_DATA_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + EVENT_MESG_DATA_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } EVENT_MESG_DATA_FIELD_SUBFIELD_INDEX; + + typedef enum + { + EVENT_MESG_START_TIMESTAMP_FIELD_AUTO_ACTIVITY_DETECT_START_TIMESTAMP, + EVENT_MESG_START_TIMESTAMP_FIELD_SUBFIELDS, + EVENT_MESG_START_TIMESTAMP_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + EVENT_MESG_START_TIMESTAMP_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } EVENT_MESG_START_TIMESTAMP_FIELD_SUBFIELD_INDEX; + + typedef enum + { + DEVICE_INFO_MESG_TIMESTAMP, + DEVICE_INFO_MESG_DEVICE_INDEX, + DEVICE_INFO_MESG_DEVICE_TYPE, + DEVICE_INFO_MESG_MANUFACTURER, + DEVICE_INFO_MESG_SERIAL_NUMBER, + DEVICE_INFO_MESG_PRODUCT, + DEVICE_INFO_MESG_SOFTWARE_VERSION, + DEVICE_INFO_MESG_HARDWARE_VERSION, + DEVICE_INFO_MESG_CUM_OPERATING_TIME, + DEVICE_INFO_MESG_BATTERY_VOLTAGE, + DEVICE_INFO_MESG_BATTERY_STATUS, + DEVICE_INFO_MESG_SENSOR_POSITION, + DEVICE_INFO_MESG_DESCRIPTOR, + DEVICE_INFO_MESG_ANT_TRANSMISSION_TYPE, + DEVICE_INFO_MESG_ANT_DEVICE_NUMBER, + DEVICE_INFO_MESG_ANT_NETWORK, + DEVICE_INFO_MESG_SOURCE_TYPE, + DEVICE_INFO_MESG_PRODUCT_NAME, + DEVICE_INFO_MESG_BATTERY_LEVEL, + DEVICE_INFO_MESG_FIELDS + } DEVICE_INFO_MESG_FIELD_INDEX; + + typedef enum + { + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_BLE_DEVICE_TYPE, + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANTPLUS_DEVICE_TYPE, + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ANT_DEVICE_TYPE, + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_LOCAL_DEVICE_TYPE, + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_SUBFIELDS, + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } DEVICE_INFO_MESG_DEVICE_TYPE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + DEVICE_INFO_MESG_PRODUCT_FIELD_FAVERO_PRODUCT, + DEVICE_INFO_MESG_PRODUCT_FIELD_GARMIN_PRODUCT, + DEVICE_INFO_MESG_PRODUCT_FIELD_SUBFIELDS, + DEVICE_INFO_MESG_PRODUCT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + DEVICE_INFO_MESG_PRODUCT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } DEVICE_INFO_MESG_PRODUCT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + DEVICE_AUX_BATTERY_INFO_MESG_TIMESTAMP, + DEVICE_AUX_BATTERY_INFO_MESG_DEVICE_INDEX, + DEVICE_AUX_BATTERY_INFO_MESG_BATTERY_VOLTAGE, + DEVICE_AUX_BATTERY_INFO_MESG_BATTERY_STATUS, + DEVICE_AUX_BATTERY_INFO_MESG_BATTERY_IDENTIFIER, + DEVICE_AUX_BATTERY_INFO_MESG_FIELDS + } DEVICE_AUX_BATTERY_INFO_MESG_FIELD_INDEX; + + typedef enum + { + TRAINING_FILE_MESG_TIMESTAMP, + TRAINING_FILE_MESG_TYPE, + TRAINING_FILE_MESG_MANUFACTURER, + TRAINING_FILE_MESG_PRODUCT, + TRAINING_FILE_MESG_SERIAL_NUMBER, + TRAINING_FILE_MESG_TIME_CREATED, + TRAINING_FILE_MESG_FIELDS + } TRAINING_FILE_MESG_FIELD_INDEX; + + typedef enum + { + TRAINING_FILE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT, + TRAINING_FILE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT, + TRAINING_FILE_MESG_PRODUCT_FIELD_SUBFIELDS, + TRAINING_FILE_MESG_PRODUCT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + TRAINING_FILE_MESG_PRODUCT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } TRAINING_FILE_MESG_PRODUCT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WEATHER_CONDITIONS_MESG_TIMESTAMP, + WEATHER_CONDITIONS_MESG_WEATHER_REPORT, + WEATHER_CONDITIONS_MESG_TEMPERATURE, + WEATHER_CONDITIONS_MESG_CONDITION, + WEATHER_CONDITIONS_MESG_WIND_DIRECTION, + WEATHER_CONDITIONS_MESG_WIND_SPEED, + WEATHER_CONDITIONS_MESG_PRECIPITATION_PROBABILITY, + WEATHER_CONDITIONS_MESG_TEMPERATURE_FEELS_LIKE, + WEATHER_CONDITIONS_MESG_RELATIVE_HUMIDITY, + WEATHER_CONDITIONS_MESG_LOCATION, + WEATHER_CONDITIONS_MESG_OBSERVED_AT_TIME, + WEATHER_CONDITIONS_MESG_OBSERVED_LOCATION_LAT, + WEATHER_CONDITIONS_MESG_OBSERVED_LOCATION_LONG, + WEATHER_CONDITIONS_MESG_DAY_OF_WEEK, + WEATHER_CONDITIONS_MESG_HIGH_TEMPERATURE, + WEATHER_CONDITIONS_MESG_LOW_TEMPERATURE, + WEATHER_CONDITIONS_MESG_FIELDS + } WEATHER_CONDITIONS_MESG_FIELD_INDEX; + + typedef enum + { + WEATHER_ALERT_MESG_TIMESTAMP, + WEATHER_ALERT_MESG_REPORT_ID, + WEATHER_ALERT_MESG_ISSUE_TIME, + WEATHER_ALERT_MESG_EXPIRE_TIME, + WEATHER_ALERT_MESG_SEVERITY, + WEATHER_ALERT_MESG_TYPE, + WEATHER_ALERT_MESG_FIELDS + } WEATHER_ALERT_MESG_FIELD_INDEX; + + typedef enum + { + GPS_METADATA_MESG_TIMESTAMP, + GPS_METADATA_MESG_TIMESTAMP_MS, + GPS_METADATA_MESG_POSITION_LAT, + GPS_METADATA_MESG_POSITION_LONG, + GPS_METADATA_MESG_ENHANCED_ALTITUDE, + GPS_METADATA_MESG_ENHANCED_SPEED, + GPS_METADATA_MESG_HEADING, + GPS_METADATA_MESG_UTC_TIMESTAMP, + GPS_METADATA_MESG_VELOCITY, + GPS_METADATA_MESG_FIELDS + } GPS_METADATA_MESG_FIELD_INDEX; + + typedef enum + { + CAMERA_EVENT_MESG_TIMESTAMP, + CAMERA_EVENT_MESG_TIMESTAMP_MS, + CAMERA_EVENT_MESG_CAMERA_EVENT_TYPE, + CAMERA_EVENT_MESG_CAMERA_FILE_UUID, + CAMERA_EVENT_MESG_CAMERA_ORIENTATION, + CAMERA_EVENT_MESG_FIELDS + } CAMERA_EVENT_MESG_FIELD_INDEX; + + typedef enum + { + GYROSCOPE_DATA_MESG_TIMESTAMP, + GYROSCOPE_DATA_MESG_TIMESTAMP_MS, + GYROSCOPE_DATA_MESG_SAMPLE_TIME_OFFSET, + GYROSCOPE_DATA_MESG_GYRO_X, + GYROSCOPE_DATA_MESG_GYRO_Y, + GYROSCOPE_DATA_MESG_GYRO_Z, + GYROSCOPE_DATA_MESG_CALIBRATED_GYRO_X, + GYROSCOPE_DATA_MESG_CALIBRATED_GYRO_Y, + GYROSCOPE_DATA_MESG_CALIBRATED_GYRO_Z, + GYROSCOPE_DATA_MESG_FIELDS + } GYROSCOPE_DATA_MESG_FIELD_INDEX; + + typedef enum + { + ACCELEROMETER_DATA_MESG_TIMESTAMP, + ACCELEROMETER_DATA_MESG_TIMESTAMP_MS, + ACCELEROMETER_DATA_MESG_SAMPLE_TIME_OFFSET, + ACCELEROMETER_DATA_MESG_ACCEL_X, + ACCELEROMETER_DATA_MESG_ACCEL_Y, + ACCELEROMETER_DATA_MESG_ACCEL_Z, + ACCELEROMETER_DATA_MESG_CALIBRATED_ACCEL_X, + ACCELEROMETER_DATA_MESG_CALIBRATED_ACCEL_Y, + ACCELEROMETER_DATA_MESG_CALIBRATED_ACCEL_Z, + ACCELEROMETER_DATA_MESG_COMPRESSED_CALIBRATED_ACCEL_X, + ACCELEROMETER_DATA_MESG_COMPRESSED_CALIBRATED_ACCEL_Y, + ACCELEROMETER_DATA_MESG_COMPRESSED_CALIBRATED_ACCEL_Z, + ACCELEROMETER_DATA_MESG_FIELDS + } ACCELEROMETER_DATA_MESG_FIELD_INDEX; + + typedef enum + { + MAGNETOMETER_DATA_MESG_TIMESTAMP, + MAGNETOMETER_DATA_MESG_TIMESTAMP_MS, + MAGNETOMETER_DATA_MESG_SAMPLE_TIME_OFFSET, + MAGNETOMETER_DATA_MESG_MAG_X, + MAGNETOMETER_DATA_MESG_MAG_Y, + MAGNETOMETER_DATA_MESG_MAG_Z, + MAGNETOMETER_DATA_MESG_CALIBRATED_MAG_X, + MAGNETOMETER_DATA_MESG_CALIBRATED_MAG_Y, + MAGNETOMETER_DATA_MESG_CALIBRATED_MAG_Z, + MAGNETOMETER_DATA_MESG_FIELDS + } MAGNETOMETER_DATA_MESG_FIELD_INDEX; + + typedef enum + { + BAROMETER_DATA_MESG_TIMESTAMP, + BAROMETER_DATA_MESG_TIMESTAMP_MS, + BAROMETER_DATA_MESG_SAMPLE_TIME_OFFSET, + BAROMETER_DATA_MESG_BARO_PRES, + BAROMETER_DATA_MESG_FIELDS + } BAROMETER_DATA_MESG_FIELD_INDEX; + + typedef enum + { + THREE_D_SENSOR_CALIBRATION_MESG_TIMESTAMP, + THREE_D_SENSOR_CALIBRATION_MESG_SENSOR_TYPE, + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR, + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_DIVISOR, + THREE_D_SENSOR_CALIBRATION_MESG_LEVEL_SHIFT, + THREE_D_SENSOR_CALIBRATION_MESG_OFFSET_CAL, + THREE_D_SENSOR_CALIBRATION_MESG_ORIENTATION_MATRIX, + THREE_D_SENSOR_CALIBRATION_MESG_FIELDS + } THREE_D_SENSOR_CALIBRATION_MESG_FIELD_INDEX; + + typedef enum + { + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACCEL_CAL_FACTOR, + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_GYRO_CAL_FACTOR, + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_SUBFIELDS, + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_SUBFIELD_INDEX; + + typedef enum + { + ONE_D_SENSOR_CALIBRATION_MESG_TIMESTAMP, + ONE_D_SENSOR_CALIBRATION_MESG_SENSOR_TYPE, + ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR, + ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_DIVISOR, + ONE_D_SENSOR_CALIBRATION_MESG_LEVEL_SHIFT, + ONE_D_SENSOR_CALIBRATION_MESG_OFFSET_CAL, + ONE_D_SENSOR_CALIBRATION_MESG_FIELDS + } ONE_D_SENSOR_CALIBRATION_MESG_FIELD_INDEX; + + typedef enum + { + ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_BARO_CAL_FACTOR, + ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_SUBFIELDS, + ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } ONE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_SUBFIELD_INDEX; + + typedef enum + { + VIDEO_FRAME_MESG_TIMESTAMP, + VIDEO_FRAME_MESG_TIMESTAMP_MS, + VIDEO_FRAME_MESG_FRAME_NUMBER, + VIDEO_FRAME_MESG_FIELDS + } VIDEO_FRAME_MESG_FIELD_INDEX; + + typedef enum + { + OBDII_DATA_MESG_TIMESTAMP, + OBDII_DATA_MESG_TIMESTAMP_MS, + OBDII_DATA_MESG_TIME_OFFSET, + OBDII_DATA_MESG_PID, + OBDII_DATA_MESG_RAW_DATA, + OBDII_DATA_MESG_PID_DATA_SIZE, + OBDII_DATA_MESG_SYSTEM_TIME, + OBDII_DATA_MESG_START_TIMESTAMP, + OBDII_DATA_MESG_START_TIMESTAMP_MS, + OBDII_DATA_MESG_FIELDS + } OBDII_DATA_MESG_FIELD_INDEX; + + typedef enum + { + NMEA_SENTENCE_MESG_TIMESTAMP, + NMEA_SENTENCE_MESG_TIMESTAMP_MS, + NMEA_SENTENCE_MESG_SENTENCE, + NMEA_SENTENCE_MESG_FIELDS + } NMEA_SENTENCE_MESG_FIELD_INDEX; + + typedef enum + { + AVIATION_ATTITUDE_MESG_TIMESTAMP, + AVIATION_ATTITUDE_MESG_TIMESTAMP_MS, + AVIATION_ATTITUDE_MESG_SYSTEM_TIME, + AVIATION_ATTITUDE_MESG_PITCH, + AVIATION_ATTITUDE_MESG_ROLL, + AVIATION_ATTITUDE_MESG_ACCEL_LATERAL, + AVIATION_ATTITUDE_MESG_ACCEL_NORMAL, + AVIATION_ATTITUDE_MESG_TURN_RATE, + AVIATION_ATTITUDE_MESG_STAGE, + AVIATION_ATTITUDE_MESG_ATTITUDE_STAGE_COMPLETE, + AVIATION_ATTITUDE_MESG_TRACK, + AVIATION_ATTITUDE_MESG_VALIDITY, + AVIATION_ATTITUDE_MESG_FIELDS + } AVIATION_ATTITUDE_MESG_FIELD_INDEX; + + typedef enum + { + VIDEO_MESG_URL, + VIDEO_MESG_HOSTING_PROVIDER, + VIDEO_MESG_DURATION, + VIDEO_MESG_FIELDS + } VIDEO_MESG_FIELD_INDEX; + + typedef enum + { + VIDEO_TITLE_MESG_MESSAGE_INDEX, + VIDEO_TITLE_MESG_MESSAGE_COUNT, + VIDEO_TITLE_MESG_TEXT, + VIDEO_TITLE_MESG_FIELDS + } VIDEO_TITLE_MESG_FIELD_INDEX; + + typedef enum + { + VIDEO_DESCRIPTION_MESG_MESSAGE_INDEX, + VIDEO_DESCRIPTION_MESG_MESSAGE_COUNT, + VIDEO_DESCRIPTION_MESG_TEXT, + VIDEO_DESCRIPTION_MESG_FIELDS + } VIDEO_DESCRIPTION_MESG_FIELD_INDEX; + + typedef enum + { + VIDEO_CLIP_MESG_CLIP_NUMBER, + VIDEO_CLIP_MESG_START_TIMESTAMP, + VIDEO_CLIP_MESG_START_TIMESTAMP_MS, + VIDEO_CLIP_MESG_END_TIMESTAMP, + VIDEO_CLIP_MESG_END_TIMESTAMP_MS, + VIDEO_CLIP_MESG_CLIP_START, + VIDEO_CLIP_MESG_CLIP_END, + VIDEO_CLIP_MESG_FIELDS + } VIDEO_CLIP_MESG_FIELD_INDEX; + + typedef enum + { + SET_MESG_TIMESTAMP, + SET_MESG_DURATION, + SET_MESG_REPETITIONS, + SET_MESG_WEIGHT, + SET_MESG_SET_TYPE, + SET_MESG_START_TIME, + SET_MESG_CATEGORY, + SET_MESG_CATEGORY_SUBTYPE, + SET_MESG_WEIGHT_DISPLAY_UNIT, + SET_MESG_MESSAGE_INDEX, + SET_MESG_WKT_STEP_INDEX, + SET_MESG_FIELDS + } SET_MESG_FIELD_INDEX; + + typedef enum + { + JUMP_MESG_TIMESTAMP, + JUMP_MESG_DISTANCE, + JUMP_MESG_HEIGHT, + JUMP_MESG_ROTATIONS, + JUMP_MESG_HANG_TIME, + JUMP_MESG_SCORE, + JUMP_MESG_POSITION_LAT, + JUMP_MESG_POSITION_LONG, + JUMP_MESG_SPEED, + JUMP_MESG_ENHANCED_SPEED, + JUMP_MESG_FIELDS + } JUMP_MESG_FIELD_INDEX; + + typedef enum + { + SPLIT_MESG_MESSAGE_INDEX, + SPLIT_MESG_SPLIT_TYPE, + SPLIT_MESG_TOTAL_ELAPSED_TIME, + SPLIT_MESG_TOTAL_TIMER_TIME, + SPLIT_MESG_TOTAL_DISTANCE, + SPLIT_MESG_AVG_SPEED, + SPLIT_MESG_START_TIME, + SPLIT_MESG_TOTAL_ASCENT, + SPLIT_MESG_TOTAL_DESCENT, + SPLIT_MESG_START_POSITION_LAT, + SPLIT_MESG_START_POSITION_LONG, + SPLIT_MESG_END_POSITION_LAT, + SPLIT_MESG_END_POSITION_LONG, + SPLIT_MESG_MAX_SPEED, + SPLIT_MESG_AVG_VERT_SPEED, + SPLIT_MESG_END_TIME, + SPLIT_MESG_TOTAL_CALORIES, + SPLIT_MESG_START_ELEVATION, + SPLIT_MESG_TOTAL_MOVING_TIME, + SPLIT_MESG_FIELDS + } SPLIT_MESG_FIELD_INDEX; + + typedef enum + { + SPLIT_SUMMARY_MESG_MESSAGE_INDEX, + SPLIT_SUMMARY_MESG_SPLIT_TYPE, + SPLIT_SUMMARY_MESG_NUM_SPLITS, + SPLIT_SUMMARY_MESG_TOTAL_TIMER_TIME, + SPLIT_SUMMARY_MESG_TOTAL_DISTANCE, + SPLIT_SUMMARY_MESG_AVG_SPEED, + SPLIT_SUMMARY_MESG_MAX_SPEED, + SPLIT_SUMMARY_MESG_TOTAL_ASCENT, + SPLIT_SUMMARY_MESG_TOTAL_DESCENT, + SPLIT_SUMMARY_MESG_AVG_HEART_RATE, + SPLIT_SUMMARY_MESG_MAX_HEART_RATE, + SPLIT_SUMMARY_MESG_AVG_VERT_SPEED, + SPLIT_SUMMARY_MESG_TOTAL_CALORIES, + SPLIT_SUMMARY_MESG_TOTAL_MOVING_TIME, + SPLIT_SUMMARY_MESG_FIELDS + } SPLIT_SUMMARY_MESG_FIELD_INDEX; + + typedef enum + { + CLIMB_PRO_MESG_TIMESTAMP, + CLIMB_PRO_MESG_POSITION_LAT, + CLIMB_PRO_MESG_POSITION_LONG, + CLIMB_PRO_MESG_CLIMB_PRO_EVENT, + CLIMB_PRO_MESG_CLIMB_NUMBER, + CLIMB_PRO_MESG_CLIMB_CATEGORY, + CLIMB_PRO_MESG_CURRENT_DIST, + CLIMB_PRO_MESG_FIELDS + } CLIMB_PRO_MESG_FIELD_INDEX; + + typedef enum + { + FIELD_DESCRIPTION_MESG_DEVELOPER_DATA_INDEX, + FIELD_DESCRIPTION_MESG_FIELD_DEFINITION_NUMBER, + FIELD_DESCRIPTION_MESG_FIT_BASE_TYPE_ID, + FIELD_DESCRIPTION_MESG_FIELD_NAME, + FIELD_DESCRIPTION_MESG_ARRAY, + FIELD_DESCRIPTION_MESG_COMPONENTS, + FIELD_DESCRIPTION_MESG_SCALE, + FIELD_DESCRIPTION_MESG_OFFSET, + FIELD_DESCRIPTION_MESG_UNITS, + FIELD_DESCRIPTION_MESG_BITS, + FIELD_DESCRIPTION_MESG_ACCUMULATE, + FIELD_DESCRIPTION_MESG_FIT_BASE_UNIT_ID, + FIELD_DESCRIPTION_MESG_NATIVE_MESG_NUM, + FIELD_DESCRIPTION_MESG_NATIVE_FIELD_NUM, + FIELD_DESCRIPTION_MESG_FIELDS + } FIELD_DESCRIPTION_MESG_FIELD_INDEX; + + typedef enum + { + DEVELOPER_DATA_ID_MESG_DEVELOPER_ID, + DEVELOPER_DATA_ID_MESG_APPLICATION_ID, + DEVELOPER_DATA_ID_MESG_MANUFACTURER_ID, + DEVELOPER_DATA_ID_MESG_DEVELOPER_DATA_INDEX, + DEVELOPER_DATA_ID_MESG_APPLICATION_VERSION, + DEVELOPER_DATA_ID_MESG_FIELDS + } DEVELOPER_DATA_ID_MESG_FIELD_INDEX; + + typedef enum + { + COURSE_MESG_SPORT, + COURSE_MESG_NAME, + COURSE_MESG_CAPABILITIES, + COURSE_MESG_SUB_SPORT, + COURSE_MESG_FIELDS + } COURSE_MESG_FIELD_INDEX; + + typedef enum + { + COURSE_POINT_MESG_MESSAGE_INDEX, + COURSE_POINT_MESG_TIMESTAMP, + COURSE_POINT_MESG_POSITION_LAT, + COURSE_POINT_MESG_POSITION_LONG, + COURSE_POINT_MESG_DISTANCE, + COURSE_POINT_MESG_TYPE, + COURSE_POINT_MESG_NAME, + COURSE_POINT_MESG_FAVORITE, + COURSE_POINT_MESG_FIELDS + } COURSE_POINT_MESG_FIELD_INDEX; + + typedef enum + { + SEGMENT_ID_MESG_NAME, + SEGMENT_ID_MESG_UUID, + SEGMENT_ID_MESG_SPORT, + SEGMENT_ID_MESG_ENABLED, + SEGMENT_ID_MESG_USER_PROFILE_PRIMARY_KEY, + SEGMENT_ID_MESG_DEVICE_ID, + SEGMENT_ID_MESG_DEFAULT_RACE_LEADER, + SEGMENT_ID_MESG_DELETE_STATUS, + SEGMENT_ID_MESG_SELECTION_TYPE, + SEGMENT_ID_MESG_FIELDS + } SEGMENT_ID_MESG_FIELD_INDEX; + + typedef enum + { + SEGMENT_LEADERBOARD_ENTRY_MESG_MESSAGE_INDEX, + SEGMENT_LEADERBOARD_ENTRY_MESG_NAME, + SEGMENT_LEADERBOARD_ENTRY_MESG_TYPE, + SEGMENT_LEADERBOARD_ENTRY_MESG_GROUP_PRIMARY_KEY, + SEGMENT_LEADERBOARD_ENTRY_MESG_ACTIVITY_ID, + SEGMENT_LEADERBOARD_ENTRY_MESG_SEGMENT_TIME, + SEGMENT_LEADERBOARD_ENTRY_MESG_ACTIVITY_ID_STRING, + SEGMENT_LEADERBOARD_ENTRY_MESG_FIELDS + } SEGMENT_LEADERBOARD_ENTRY_MESG_FIELD_INDEX; + + typedef enum + { + SEGMENT_POINT_MESG_MESSAGE_INDEX, + SEGMENT_POINT_MESG_POSITION_LAT, + SEGMENT_POINT_MESG_POSITION_LONG, + SEGMENT_POINT_MESG_DISTANCE, + SEGMENT_POINT_MESG_ALTITUDE, + SEGMENT_POINT_MESG_LEADER_TIME, + SEGMENT_POINT_MESG_ENHANCED_ALTITUDE, + SEGMENT_POINT_MESG_FIELDS + } SEGMENT_POINT_MESG_FIELD_INDEX; + + typedef enum + { + SEGMENT_LAP_MESG_MESSAGE_INDEX, + SEGMENT_LAP_MESG_TIMESTAMP, + SEGMENT_LAP_MESG_EVENT, + SEGMENT_LAP_MESG_EVENT_TYPE, + SEGMENT_LAP_MESG_START_TIME, + SEGMENT_LAP_MESG_START_POSITION_LAT, + SEGMENT_LAP_MESG_START_POSITION_LONG, + SEGMENT_LAP_MESG_END_POSITION_LAT, + SEGMENT_LAP_MESG_END_POSITION_LONG, + SEGMENT_LAP_MESG_TOTAL_ELAPSED_TIME, + SEGMENT_LAP_MESG_TOTAL_TIMER_TIME, + SEGMENT_LAP_MESG_TOTAL_DISTANCE, + SEGMENT_LAP_MESG_TOTAL_CYCLES, + SEGMENT_LAP_MESG_TOTAL_CALORIES, + SEGMENT_LAP_MESG_TOTAL_FAT_CALORIES, + SEGMENT_LAP_MESG_AVG_SPEED, + SEGMENT_LAP_MESG_MAX_SPEED, + SEGMENT_LAP_MESG_AVG_HEART_RATE, + SEGMENT_LAP_MESG_MAX_HEART_RATE, + SEGMENT_LAP_MESG_AVG_CADENCE, + SEGMENT_LAP_MESG_MAX_CADENCE, + SEGMENT_LAP_MESG_AVG_POWER, + SEGMENT_LAP_MESG_MAX_POWER, + SEGMENT_LAP_MESG_TOTAL_ASCENT, + SEGMENT_LAP_MESG_TOTAL_DESCENT, + SEGMENT_LAP_MESG_SPORT, + SEGMENT_LAP_MESG_EVENT_GROUP, + SEGMENT_LAP_MESG_NEC_LAT, + SEGMENT_LAP_MESG_NEC_LONG, + SEGMENT_LAP_MESG_SWC_LAT, + SEGMENT_LAP_MESG_SWC_LONG, + SEGMENT_LAP_MESG_NAME, + SEGMENT_LAP_MESG_NORMALIZED_POWER, + SEGMENT_LAP_MESG_LEFT_RIGHT_BALANCE, + SEGMENT_LAP_MESG_SUB_SPORT, + SEGMENT_LAP_MESG_TOTAL_WORK, + SEGMENT_LAP_MESG_AVG_ALTITUDE, + SEGMENT_LAP_MESG_MAX_ALTITUDE, + SEGMENT_LAP_MESG_GPS_ACCURACY, + SEGMENT_LAP_MESG_AVG_GRADE, + SEGMENT_LAP_MESG_AVG_POS_GRADE, + SEGMENT_LAP_MESG_AVG_NEG_GRADE, + SEGMENT_LAP_MESG_MAX_POS_GRADE, + SEGMENT_LAP_MESG_MAX_NEG_GRADE, + SEGMENT_LAP_MESG_AVG_TEMPERATURE, + SEGMENT_LAP_MESG_MAX_TEMPERATURE, + SEGMENT_LAP_MESG_TOTAL_MOVING_TIME, + SEGMENT_LAP_MESG_AVG_POS_VERTICAL_SPEED, + SEGMENT_LAP_MESG_AVG_NEG_VERTICAL_SPEED, + SEGMENT_LAP_MESG_MAX_POS_VERTICAL_SPEED, + SEGMENT_LAP_MESG_MAX_NEG_VERTICAL_SPEED, + SEGMENT_LAP_MESG_TIME_IN_HR_ZONE, + SEGMENT_LAP_MESG_TIME_IN_SPEED_ZONE, + SEGMENT_LAP_MESG_TIME_IN_CADENCE_ZONE, + SEGMENT_LAP_MESG_TIME_IN_POWER_ZONE, + SEGMENT_LAP_MESG_REPETITION_NUM, + SEGMENT_LAP_MESG_MIN_ALTITUDE, + SEGMENT_LAP_MESG_MIN_HEART_RATE, + SEGMENT_LAP_MESG_ACTIVE_TIME, + SEGMENT_LAP_MESG_WKT_STEP_INDEX, + SEGMENT_LAP_MESG_SPORT_EVENT, + SEGMENT_LAP_MESG_AVG_LEFT_TORQUE_EFFECTIVENESS, + SEGMENT_LAP_MESG_AVG_RIGHT_TORQUE_EFFECTIVENESS, + SEGMENT_LAP_MESG_AVG_LEFT_PEDAL_SMOOTHNESS, + SEGMENT_LAP_MESG_AVG_RIGHT_PEDAL_SMOOTHNESS, + SEGMENT_LAP_MESG_AVG_COMBINED_PEDAL_SMOOTHNESS, + SEGMENT_LAP_MESG_STATUS, + SEGMENT_LAP_MESG_UUID, + SEGMENT_LAP_MESG_AVG_FRACTIONAL_CADENCE, + SEGMENT_LAP_MESG_MAX_FRACTIONAL_CADENCE, + SEGMENT_LAP_MESG_TOTAL_FRACTIONAL_CYCLES, + SEGMENT_LAP_MESG_FRONT_GEAR_SHIFT_COUNT, + SEGMENT_LAP_MESG_REAR_GEAR_SHIFT_COUNT, + SEGMENT_LAP_MESG_TIME_STANDING, + SEGMENT_LAP_MESG_STAND_COUNT, + SEGMENT_LAP_MESG_AVG_LEFT_PCO, + SEGMENT_LAP_MESG_AVG_RIGHT_PCO, + SEGMENT_LAP_MESG_AVG_LEFT_POWER_PHASE, + SEGMENT_LAP_MESG_AVG_LEFT_POWER_PHASE_PEAK, + SEGMENT_LAP_MESG_AVG_RIGHT_POWER_PHASE, + SEGMENT_LAP_MESG_AVG_RIGHT_POWER_PHASE_PEAK, + SEGMENT_LAP_MESG_AVG_POWER_POSITION, + SEGMENT_LAP_MESG_MAX_POWER_POSITION, + SEGMENT_LAP_MESG_AVG_CADENCE_POSITION, + SEGMENT_LAP_MESG_MAX_CADENCE_POSITION, + SEGMENT_LAP_MESG_MANUFACTURER, + SEGMENT_LAP_MESG_TOTAL_GRIT, + SEGMENT_LAP_MESG_TOTAL_FLOW, + SEGMENT_LAP_MESG_AVG_GRIT, + SEGMENT_LAP_MESG_AVG_FLOW, + SEGMENT_LAP_MESG_TOTAL_FRACTIONAL_ASCENT, + SEGMENT_LAP_MESG_TOTAL_FRACTIONAL_DESCENT, + SEGMENT_LAP_MESG_ENHANCED_AVG_ALTITUDE, + SEGMENT_LAP_MESG_ENHANCED_MAX_ALTITUDE, + SEGMENT_LAP_MESG_ENHANCED_MIN_ALTITUDE, + SEGMENT_LAP_MESG_FIELDS + } SEGMENT_LAP_MESG_FIELD_INDEX; + + typedef enum + { + SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES, + SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_SUBFIELDS, + SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_SUBFIELD_INDEX; + + typedef enum + { + SEGMENT_FILE_MESG_MESSAGE_INDEX, + SEGMENT_FILE_MESG_FILE_UUID, + SEGMENT_FILE_MESG_ENABLED, + SEGMENT_FILE_MESG_USER_PROFILE_PRIMARY_KEY, + SEGMENT_FILE_MESG_LEADER_TYPE, + SEGMENT_FILE_MESG_LEADER_GROUP_PRIMARY_KEY, + SEGMENT_FILE_MESG_LEADER_ACTIVITY_ID, + SEGMENT_FILE_MESG_LEADER_ACTIVITY_ID_STRING, + SEGMENT_FILE_MESG_DEFAULT_RACE_LEADER, + SEGMENT_FILE_MESG_FIELDS + } SEGMENT_FILE_MESG_FIELD_INDEX; + + typedef enum + { + WORKOUT_MESG_MESSAGE_INDEX, + WORKOUT_MESG_SPORT, + WORKOUT_MESG_CAPABILITIES, + WORKOUT_MESG_NUM_VALID_STEPS, + WORKOUT_MESG_WKT_NAME, + WORKOUT_MESG_SUB_SPORT, + WORKOUT_MESG_POOL_LENGTH, + WORKOUT_MESG_POOL_LENGTH_UNIT, + WORKOUT_MESG_WKT_DESCRIPTION, + WORKOUT_MESG_FIELDS + } WORKOUT_MESG_FIELD_INDEX; + + typedef enum + { + WORKOUT_SESSION_MESG_MESSAGE_INDEX, + WORKOUT_SESSION_MESG_SPORT, + WORKOUT_SESSION_MESG_SUB_SPORT, + WORKOUT_SESSION_MESG_NUM_VALID_STEPS, + WORKOUT_SESSION_MESG_FIRST_STEP_INDEX, + WORKOUT_SESSION_MESG_POOL_LENGTH, + WORKOUT_SESSION_MESG_POOL_LENGTH_UNIT, + WORKOUT_SESSION_MESG_FIELDS + } WORKOUT_SESSION_MESG_FIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_MESSAGE_INDEX, + WORKOUT_STEP_MESG_WKT_STEP_NAME, + WORKOUT_STEP_MESG_DURATION_TYPE, + WORKOUT_STEP_MESG_DURATION_VALUE, + WORKOUT_STEP_MESG_TARGET_TYPE, + WORKOUT_STEP_MESG_TARGET_VALUE, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH, + WORKOUT_STEP_MESG_INTENSITY, + WORKOUT_STEP_MESG_NOTES, + WORKOUT_STEP_MESG_EQUIPMENT, + WORKOUT_STEP_MESG_EXERCISE_CATEGORY, + WORKOUT_STEP_MESG_EXERCISE_NAME, + WORKOUT_STEP_MESG_EXERCISE_WEIGHT, + WORKOUT_STEP_MESG_WEIGHT_DISPLAY_UNIT, + WORKOUT_STEP_MESG_SECONDARY_TARGET_TYPE, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH, + WORKOUT_STEP_MESG_FIELDS + } WORKOUT_STEP_MESG_FIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_TIME, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_DISTANCE, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_HR, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_CALORIES, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_STEP, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_POWER, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_REPS, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_SPEED_ZONE, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_HR_ZONE, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_CADENCE_ZONE, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_POWER_ZONE, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_STEPS, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_TIME, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_DISTANCE, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_CALORIES, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_HR, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_POWER, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_STROKE_TYPE, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_SPEED_LOW, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_HEART_RATE_LOW, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_CADENCE_LOW, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_POWER_LOW, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_SPEED_HIGH, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_HEART_RATE_HIGH, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_CADENCE_HIGH, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_POWER_HIGH, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_SPEED_ZONE, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_HR_ZONE, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_CADENCE_ZONE, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_POWER_ZONE, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_STROKE_TYPE, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_LOW, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_LOW, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_LOW, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_POWER_LOW, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SUBFIELD_INDEX; + + typedef enum + { + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_HIGH, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_HIGH, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_HIGH, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_POWER_HIGH, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SUBFIELDS, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SUBFIELD_INDEX; + + typedef enum + { + EXERCISE_TITLE_MESG_MESSAGE_INDEX, + EXERCISE_TITLE_MESG_EXERCISE_CATEGORY, + EXERCISE_TITLE_MESG_EXERCISE_NAME, + EXERCISE_TITLE_MESG_WKT_STEP_NAME, + EXERCISE_TITLE_MESG_FIELDS + } EXERCISE_TITLE_MESG_FIELD_INDEX; + + typedef enum + { + SCHEDULE_MESG_MANUFACTURER, + SCHEDULE_MESG_PRODUCT, + SCHEDULE_MESG_SERIAL_NUMBER, + SCHEDULE_MESG_TIME_CREATED, + SCHEDULE_MESG_COMPLETED, + SCHEDULE_MESG_TYPE, + SCHEDULE_MESG_SCHEDULED_TIME, + SCHEDULE_MESG_FIELDS + } SCHEDULE_MESG_FIELD_INDEX; + + typedef enum + { + SCHEDULE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT, + SCHEDULE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT, + SCHEDULE_MESG_PRODUCT_FIELD_SUBFIELDS, + SCHEDULE_MESG_PRODUCT_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + SCHEDULE_MESG_PRODUCT_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } SCHEDULE_MESG_PRODUCT_FIELD_SUBFIELD_INDEX; + + typedef enum + { + TOTALS_MESG_MESSAGE_INDEX, + TOTALS_MESG_TIMESTAMP, + TOTALS_MESG_TIMER_TIME, + TOTALS_MESG_DISTANCE, + TOTALS_MESG_CALORIES, + TOTALS_MESG_SPORT, + TOTALS_MESG_ELAPSED_TIME, + TOTALS_MESG_SESSIONS, + TOTALS_MESG_ACTIVE_TIME, + TOTALS_MESG_SPORT_INDEX, + TOTALS_MESG_FIELDS + } TOTALS_MESG_FIELD_INDEX; + + typedef enum + { + WEIGHT_SCALE_MESG_TIMESTAMP, + WEIGHT_SCALE_MESG_WEIGHT, + WEIGHT_SCALE_MESG_PERCENT_FAT, + WEIGHT_SCALE_MESG_PERCENT_HYDRATION, + WEIGHT_SCALE_MESG_VISCERAL_FAT_MASS, + WEIGHT_SCALE_MESG_BONE_MASS, + WEIGHT_SCALE_MESG_MUSCLE_MASS, + WEIGHT_SCALE_MESG_BASAL_MET, + WEIGHT_SCALE_MESG_PHYSIQUE_RATING, + WEIGHT_SCALE_MESG_ACTIVE_MET, + WEIGHT_SCALE_MESG_METABOLIC_AGE, + WEIGHT_SCALE_MESG_VISCERAL_FAT_RATING, + WEIGHT_SCALE_MESG_USER_PROFILE_INDEX, + WEIGHT_SCALE_MESG_BMI, + WEIGHT_SCALE_MESG_FIELDS + } WEIGHT_SCALE_MESG_FIELD_INDEX; + + typedef enum + { + BLOOD_PRESSURE_MESG_TIMESTAMP, + BLOOD_PRESSURE_MESG_SYSTOLIC_PRESSURE, + BLOOD_PRESSURE_MESG_DIASTOLIC_PRESSURE, + BLOOD_PRESSURE_MESG_MEAN_ARTERIAL_PRESSURE, + BLOOD_PRESSURE_MESG_MAP_3_SAMPLE_MEAN, + BLOOD_PRESSURE_MESG_MAP_MORNING_VALUES, + BLOOD_PRESSURE_MESG_MAP_EVENING_VALUES, + BLOOD_PRESSURE_MESG_HEART_RATE, + BLOOD_PRESSURE_MESG_HEART_RATE_TYPE, + BLOOD_PRESSURE_MESG_STATUS, + BLOOD_PRESSURE_MESG_USER_PROFILE_INDEX, + BLOOD_PRESSURE_MESG_FIELDS + } BLOOD_PRESSURE_MESG_FIELD_INDEX; + + typedef enum + { + MONITORING_INFO_MESG_TIMESTAMP, + MONITORING_INFO_MESG_LOCAL_TIMESTAMP, + MONITORING_INFO_MESG_ACTIVITY_TYPE, + MONITORING_INFO_MESG_CYCLES_TO_DISTANCE, + MONITORING_INFO_MESG_CYCLES_TO_CALORIES, + MONITORING_INFO_MESG_RESTING_METABOLIC_RATE, + MONITORING_INFO_MESG_FIELDS + } MONITORING_INFO_MESG_FIELD_INDEX; + + typedef enum + { + MONITORING_MESG_TIMESTAMP, + MONITORING_MESG_DEVICE_INDEX, + MONITORING_MESG_CALORIES, + MONITORING_MESG_DISTANCE, + MONITORING_MESG_CYCLES, + MONITORING_MESG_ACTIVE_TIME, + MONITORING_MESG_ACTIVITY_TYPE, + MONITORING_MESG_ACTIVITY_SUBTYPE, + MONITORING_MESG_ACTIVITY_LEVEL, + MONITORING_MESG_DISTANCE_16, + MONITORING_MESG_CYCLES_16, + MONITORING_MESG_ACTIVE_TIME_16, + MONITORING_MESG_LOCAL_TIMESTAMP, + MONITORING_MESG_TEMPERATURE, + MONITORING_MESG_TEMPERATURE_MIN, + MONITORING_MESG_TEMPERATURE_MAX, + MONITORING_MESG_ACTIVITY_TIME, + MONITORING_MESG_ACTIVE_CALORIES, + MONITORING_MESG_CURRENT_ACTIVITY_TYPE_INTENSITY, + MONITORING_MESG_TIMESTAMP_MIN_8, + MONITORING_MESG_TIMESTAMP_16, + MONITORING_MESG_HEART_RATE, + MONITORING_MESG_INTENSITY, + MONITORING_MESG_DURATION_MIN, + MONITORING_MESG_DURATION, + MONITORING_MESG_ASCENT, + MONITORING_MESG_DESCENT, + MONITORING_MESG_MODERATE_ACTIVITY_MINUTES, + MONITORING_MESG_VIGOROUS_ACTIVITY_MINUTES, + MONITORING_MESG_FIELDS + } MONITORING_MESG_FIELD_INDEX; + + typedef enum + { + MONITORING_MESG_CYCLES_FIELD_STEPS, + MONITORING_MESG_CYCLES_FIELD_STROKES, + MONITORING_MESG_CYCLES_FIELD_SUBFIELDS, + MONITORING_MESG_CYCLES_FIELD_ACTIVE_SUBFIELD = FIT_SUBFIELD_INDEX_ACTIVE_SUBFIELD, + MONITORING_MESG_CYCLES_FIELD_MAIN_FIELD = FIT_SUBFIELD_INDEX_MAIN_FIELD + } MONITORING_MESG_CYCLES_FIELD_SUBFIELD_INDEX; + + typedef enum + { + MONITORING_HR_DATA_MESG_TIMESTAMP, + MONITORING_HR_DATA_MESG_RESTING_HEART_RATE, + MONITORING_HR_DATA_MESG_CURRENT_DAY_RESTING_HEART_RATE, + MONITORING_HR_DATA_MESG_FIELDS + } MONITORING_HR_DATA_MESG_FIELD_INDEX; + + typedef enum + { + SPO2_DATA_MESG_TIMESTAMP, + SPO2_DATA_MESG_READING_SPO2, + SPO2_DATA_MESG_READING_CONFIDENCE, + SPO2_DATA_MESG_MODE, + SPO2_DATA_MESG_FIELDS + } SPO2_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HR_MESG_TIMESTAMP, + HR_MESG_FRACTIONAL_TIMESTAMP, + HR_MESG_TIME256, + HR_MESG_FILTERED_BPM, + HR_MESG_EVENT_TIMESTAMP, + HR_MESG_EVENT_TIMESTAMP_12, + HR_MESG_FIELDS + } HR_MESG_FIELD_INDEX; + + typedef enum + { + STRESS_LEVEL_MESG_STRESS_LEVEL_VALUE, + STRESS_LEVEL_MESG_STRESS_LEVEL_TIME, + STRESS_LEVEL_MESG_FIELDS + } STRESS_LEVEL_MESG_FIELD_INDEX; + + typedef enum + { + MAX_MET_DATA_MESG_UPDATE_TIME, + MAX_MET_DATA_MESG_VO2_MAX, + MAX_MET_DATA_MESG_SPORT, + MAX_MET_DATA_MESG_SUB_SPORT, + MAX_MET_DATA_MESG_MAX_MET_CATEGORY, + MAX_MET_DATA_MESG_CALIBRATED_DATA, + MAX_MET_DATA_MESG_HR_SOURCE, + MAX_MET_DATA_MESG_SPEED_SOURCE, + MAX_MET_DATA_MESG_FIELDS + } MAX_MET_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_BODY_BATTERY_DATA_MESG_TIMESTAMP, + HSA_BODY_BATTERY_DATA_MESG_PROCESSING_INTERVAL, + HSA_BODY_BATTERY_DATA_MESG_LEVEL, + HSA_BODY_BATTERY_DATA_MESG_CHARGED, + HSA_BODY_BATTERY_DATA_MESG_UNCHARGED, + HSA_BODY_BATTERY_DATA_MESG_FIELDS + } HSA_BODY_BATTERY_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_EVENT_MESG_TIMESTAMP, + HSA_EVENT_MESG_EVENT_ID, + HSA_EVENT_MESG_FIELDS + } HSA_EVENT_MESG_FIELD_INDEX; + + typedef enum + { + HSA_ACCELEROMETER_DATA_MESG_TIMESTAMP, + HSA_ACCELEROMETER_DATA_MESG_TIMESTAMP_MS, + HSA_ACCELEROMETER_DATA_MESG_SAMPLING_INTERVAL, + HSA_ACCELEROMETER_DATA_MESG_ACCEL_X, + HSA_ACCELEROMETER_DATA_MESG_ACCEL_Y, + HSA_ACCELEROMETER_DATA_MESG_ACCEL_Z, + HSA_ACCELEROMETER_DATA_MESG_TIMESTAMP_32K, + HSA_ACCELEROMETER_DATA_MESG_FIELDS + } HSA_ACCELEROMETER_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_GYROSCOPE_DATA_MESG_TIMESTAMP, + HSA_GYROSCOPE_DATA_MESG_TIMESTAMP_MS, + HSA_GYROSCOPE_DATA_MESG_SAMPLING_INTERVAL, + HSA_GYROSCOPE_DATA_MESG_GYRO_X, + HSA_GYROSCOPE_DATA_MESG_GYRO_Y, + HSA_GYROSCOPE_DATA_MESG_GYRO_Z, + HSA_GYROSCOPE_DATA_MESG_TIMESTAMP_32K, + HSA_GYROSCOPE_DATA_MESG_FIELDS + } HSA_GYROSCOPE_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_STEP_DATA_MESG_TIMESTAMP, + HSA_STEP_DATA_MESG_PROCESSING_INTERVAL, + HSA_STEP_DATA_MESG_STEPS, + HSA_STEP_DATA_MESG_FIELDS + } HSA_STEP_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_SPO2_DATA_MESG_TIMESTAMP, + HSA_SPO2_DATA_MESG_PROCESSING_INTERVAL, + HSA_SPO2_DATA_MESG_READING_SPO2, + HSA_SPO2_DATA_MESG_CONFIDENCE, + HSA_SPO2_DATA_MESG_FIELDS + } HSA_SPO2_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_STRESS_DATA_MESG_TIMESTAMP, + HSA_STRESS_DATA_MESG_PROCESSING_INTERVAL, + HSA_STRESS_DATA_MESG_STRESS_LEVEL, + HSA_STRESS_DATA_MESG_FIELDS + } HSA_STRESS_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_RESPIRATION_DATA_MESG_TIMESTAMP, + HSA_RESPIRATION_DATA_MESG_PROCESSING_INTERVAL, + HSA_RESPIRATION_DATA_MESG_RESPIRATION_RATE, + HSA_RESPIRATION_DATA_MESG_FIELDS + } HSA_RESPIRATION_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_HEART_RATE_DATA_MESG_TIMESTAMP, + HSA_HEART_RATE_DATA_MESG_PROCESSING_INTERVAL, + HSA_HEART_RATE_DATA_MESG_STATUS, + HSA_HEART_RATE_DATA_MESG_HEART_RATE, + HSA_HEART_RATE_DATA_MESG_FIELDS + } HSA_HEART_RATE_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_CONFIGURATION_DATA_MESG_TIMESTAMP, + HSA_CONFIGURATION_DATA_MESG_DATA, + HSA_CONFIGURATION_DATA_MESG_DATA_SIZE, + HSA_CONFIGURATION_DATA_MESG_FIELDS + } HSA_CONFIGURATION_DATA_MESG_FIELD_INDEX; + + typedef enum + { + HSA_WRIST_TEMPERATURE_DATA_MESG_TIMESTAMP, + HSA_WRIST_TEMPERATURE_DATA_MESG_PROCESSING_INTERVAL, + HSA_WRIST_TEMPERATURE_DATA_MESG_VALUE, + HSA_WRIST_TEMPERATURE_DATA_MESG_FIELDS + } HSA_WRIST_TEMPERATURE_DATA_MESG_FIELD_INDEX; + + typedef enum + { + MEMO_GLOB_MESG_PART_INDEX, + MEMO_GLOB_MESG_MEMO, + MEMO_GLOB_MESG_MESG_NUM, + MEMO_GLOB_MESG_PARENT_INDEX, + MEMO_GLOB_MESG_FIELD_NUM, + MEMO_GLOB_MESG_DATA, + MEMO_GLOB_MESG_FIELDS + } MEMO_GLOB_MESG_FIELD_INDEX; + + typedef enum + { + SLEEP_LEVEL_MESG_TIMESTAMP, + SLEEP_LEVEL_MESG_SLEEP_LEVEL, + SLEEP_LEVEL_MESG_FIELDS + } SLEEP_LEVEL_MESG_FIELD_INDEX; + + typedef enum + { + ANT_CHANNEL_ID_MESG_CHANNEL_NUMBER, + ANT_CHANNEL_ID_MESG_DEVICE_TYPE, + ANT_CHANNEL_ID_MESG_DEVICE_NUMBER, + ANT_CHANNEL_ID_MESG_TRANSMISSION_TYPE, + ANT_CHANNEL_ID_MESG_DEVICE_INDEX, + ANT_CHANNEL_ID_MESG_FIELDS + } ANT_CHANNEL_ID_MESG_FIELD_INDEX; + + typedef enum + { + ANT_RX_MESG_TIMESTAMP, + ANT_RX_MESG_FRACTIONAL_TIMESTAMP, + ANT_RX_MESG_MESG_ID, + ANT_RX_MESG_MESG_DATA, + ANT_RX_MESG_CHANNEL_NUMBER, + ANT_RX_MESG_DATA, + ANT_RX_MESG_FIELDS + } ANT_RX_MESG_FIELD_INDEX; + + typedef enum + { + ANT_TX_MESG_TIMESTAMP, + ANT_TX_MESG_FRACTIONAL_TIMESTAMP, + ANT_TX_MESG_MESG_ID, + ANT_TX_MESG_MESG_DATA, + ANT_TX_MESG_CHANNEL_NUMBER, + ANT_TX_MESG_DATA, + ANT_TX_MESG_FIELDS + } ANT_TX_MESG_FIELD_INDEX; + + typedef enum + { + EXD_SCREEN_CONFIGURATION_MESG_SCREEN_INDEX, + EXD_SCREEN_CONFIGURATION_MESG_FIELD_COUNT, + EXD_SCREEN_CONFIGURATION_MESG_LAYOUT, + EXD_SCREEN_CONFIGURATION_MESG_SCREEN_ENABLED, + EXD_SCREEN_CONFIGURATION_MESG_FIELDS + } EXD_SCREEN_CONFIGURATION_MESG_FIELD_INDEX; + + typedef enum + { + EXD_DATA_FIELD_CONFIGURATION_MESG_SCREEN_INDEX, + EXD_DATA_FIELD_CONFIGURATION_MESG_CONCEPT_FIELD, + EXD_DATA_FIELD_CONFIGURATION_MESG_FIELD_ID, + EXD_DATA_FIELD_CONFIGURATION_MESG_CONCEPT_COUNT, + EXD_DATA_FIELD_CONFIGURATION_MESG_DISPLAY_TYPE, + EXD_DATA_FIELD_CONFIGURATION_MESG_TITLE, + EXD_DATA_FIELD_CONFIGURATION_MESG_FIELDS + } EXD_DATA_FIELD_CONFIGURATION_MESG_FIELD_INDEX; + + typedef enum + { + EXD_DATA_CONCEPT_CONFIGURATION_MESG_SCREEN_INDEX, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_CONCEPT_FIELD, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_FIELD_ID, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_CONCEPT_INDEX, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_DATA_PAGE, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_CONCEPT_KEY, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_SCALING, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_DATA_UNITS, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_QUALIFIER, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_DESCRIPTOR, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_IS_SIGNED, + EXD_DATA_CONCEPT_CONFIGURATION_MESG_FIELDS + } EXD_DATA_CONCEPT_CONFIGURATION_MESG_FIELD_INDEX; + + typedef enum + { + DIVE_SUMMARY_MESG_TIMESTAMP, + DIVE_SUMMARY_MESG_REFERENCE_MESG, + DIVE_SUMMARY_MESG_REFERENCE_INDEX, + DIVE_SUMMARY_MESG_AVG_DEPTH, + DIVE_SUMMARY_MESG_MAX_DEPTH, + DIVE_SUMMARY_MESG_SURFACE_INTERVAL, + DIVE_SUMMARY_MESG_START_CNS, + DIVE_SUMMARY_MESG_END_CNS, + DIVE_SUMMARY_MESG_START_N2, + DIVE_SUMMARY_MESG_END_N2, + DIVE_SUMMARY_MESG_O2_TOXICITY, + DIVE_SUMMARY_MESG_DIVE_NUMBER, + DIVE_SUMMARY_MESG_BOTTOM_TIME, + DIVE_SUMMARY_MESG_AVG_PRESSURE_SAC, + DIVE_SUMMARY_MESG_AVG_VOLUME_SAC, + DIVE_SUMMARY_MESG_AVG_RMV, + DIVE_SUMMARY_MESG_DESCENT_TIME, + DIVE_SUMMARY_MESG_ASCENT_TIME, + DIVE_SUMMARY_MESG_AVG_ASCENT_RATE, + DIVE_SUMMARY_MESG_AVG_DESCENT_RATE, + DIVE_SUMMARY_MESG_MAX_ASCENT_RATE, + DIVE_SUMMARY_MESG_MAX_DESCENT_RATE, + DIVE_SUMMARY_MESG_HANG_TIME, + DIVE_SUMMARY_MESG_FIELDS + } DIVE_SUMMARY_MESG_FIELD_INDEX; + + typedef enum + { + AAD_ACCEL_FEATURES_MESG_TIMESTAMP, + AAD_ACCEL_FEATURES_MESG_TIME, + AAD_ACCEL_FEATURES_MESG_ENERGY_TOTAL, + AAD_ACCEL_FEATURES_MESG_ZERO_CROSS_CNT, + AAD_ACCEL_FEATURES_MESG_INSTANCE, + AAD_ACCEL_FEATURES_MESG_TIME_ABOVE_THRESHOLD, + AAD_ACCEL_FEATURES_MESG_FIELDS + } AAD_ACCEL_FEATURES_MESG_FIELD_INDEX; + + typedef enum + { + HRV_MESG_TIME, + HRV_MESG_FIELDS + } HRV_MESG_FIELD_INDEX; + + typedef enum + { + BEAT_INTERVALS_MESG_TIMESTAMP, + BEAT_INTERVALS_MESG_TIMESTAMP_MS, + BEAT_INTERVALS_MESG_TIME, + BEAT_INTERVALS_MESG_FIELDS + } BEAT_INTERVALS_MESG_FIELD_INDEX; + + typedef enum + { + HRV_STATUS_SUMMARY_MESG_TIMESTAMP, + HRV_STATUS_SUMMARY_MESG_WEEKLY_AVERAGE, + HRV_STATUS_SUMMARY_MESG_LAST_NIGHT_AVERAGE, + HRV_STATUS_SUMMARY_MESG_LAST_NIGHT_5_MIN_HIGH, + HRV_STATUS_SUMMARY_MESG_BASELINE_LOW_UPPER, + HRV_STATUS_SUMMARY_MESG_BASELINE_BALANCED_LOWER, + HRV_STATUS_SUMMARY_MESG_BASELINE_BALANCED_UPPER, + HRV_STATUS_SUMMARY_MESG_STATUS, + HRV_STATUS_SUMMARY_MESG_FIELDS + } HRV_STATUS_SUMMARY_MESG_FIELD_INDEX; + + typedef enum + { + HRV_VALUE_MESG_TIMESTAMP, + HRV_VALUE_MESG_VALUE, + HRV_VALUE_MESG_FIELDS + } HRV_VALUE_MESG_FIELD_INDEX; + + typedef enum + { + RAW_BBI_MESG_TIMESTAMP, + RAW_BBI_MESG_TIMESTAMP_MS, + RAW_BBI_MESG_DATA, + RAW_BBI_MESG_TIME, + RAW_BBI_MESG_QUALITY, + RAW_BBI_MESG_GAP, + RAW_BBI_MESG_FIELDS + } RAW_BBI_MESG_FIELD_INDEX; + + typedef enum + { + RESPIRATION_RATE_MESG_TIMESTAMP, + RESPIRATION_RATE_MESG_RESPIRATION_RATE, + RESPIRATION_RATE_MESG_FIELDS + } RESPIRATION_RATE_MESG_FIELD_INDEX; + + typedef enum + { + CHRONO_SHOT_SESSION_MESG_TIMESTAMP, + CHRONO_SHOT_SESSION_MESG_MIN_SPEED, + CHRONO_SHOT_SESSION_MESG_MAX_SPEED, + CHRONO_SHOT_SESSION_MESG_AVG_SPEED, + CHRONO_SHOT_SESSION_MESG_SHOT_COUNT, + CHRONO_SHOT_SESSION_MESG_PROJECTILE_TYPE, + CHRONO_SHOT_SESSION_MESG_GRAIN_WEIGHT, + CHRONO_SHOT_SESSION_MESG_STANDARD_DEVIATION, + CHRONO_SHOT_SESSION_MESG_FIELDS + } CHRONO_SHOT_SESSION_MESG_FIELD_INDEX; + + typedef enum + { + CHRONO_SHOT_DATA_MESG_TIMESTAMP, + CHRONO_SHOT_DATA_MESG_SHOT_SPEED, + CHRONO_SHOT_DATA_MESG_SHOT_NUM, + CHRONO_SHOT_DATA_MESG_FIELDS + } CHRONO_SHOT_DATA_MESG_FIELD_INDEX; + + typedef enum + { + TANK_UPDATE_MESG_TIMESTAMP, + TANK_UPDATE_MESG_SENSOR, + TANK_UPDATE_MESG_PRESSURE, + TANK_UPDATE_MESG_FIELDS + } TANK_UPDATE_MESG_FIELD_INDEX; + + typedef enum + { + TANK_SUMMARY_MESG_TIMESTAMP, + TANK_SUMMARY_MESG_SENSOR, + TANK_SUMMARY_MESG_START_PRESSURE, + TANK_SUMMARY_MESG_END_PRESSURE, + TANK_SUMMARY_MESG_VOLUME_USED, + TANK_SUMMARY_MESG_FIELDS + } TANK_SUMMARY_MESG_FIELD_INDEX; + + typedef enum + { + SLEEP_ASSESSMENT_MESG_COMBINED_AWAKE_SCORE, + SLEEP_ASSESSMENT_MESG_AWAKE_TIME_SCORE, + SLEEP_ASSESSMENT_MESG_AWAKENINGS_COUNT_SCORE, + SLEEP_ASSESSMENT_MESG_DEEP_SLEEP_SCORE, + SLEEP_ASSESSMENT_MESG_SLEEP_DURATION_SCORE, + SLEEP_ASSESSMENT_MESG_LIGHT_SLEEP_SCORE, + SLEEP_ASSESSMENT_MESG_OVERALL_SLEEP_SCORE, + SLEEP_ASSESSMENT_MESG_SLEEP_QUALITY_SCORE, + SLEEP_ASSESSMENT_MESG_SLEEP_RECOVERY_SCORE, + SLEEP_ASSESSMENT_MESG_REM_SLEEP_SCORE, + SLEEP_ASSESSMENT_MESG_SLEEP_RESTLESSNESS_SCORE, + SLEEP_ASSESSMENT_MESG_AWAKENINGS_COUNT, + SLEEP_ASSESSMENT_MESG_INTERRUPTIONS_SCORE, + SLEEP_ASSESSMENT_MESG_AVERAGE_STRESS_DURING_SLEEP, + SLEEP_ASSESSMENT_MESG_FIELDS + } SLEEP_ASSESSMENT_MESG_FIELD_INDEX; + + typedef enum + { + SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_MESSAGE_INDEX, + SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_TIMESTAMP, + SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_SEVERITY, + SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_FIELDS + } SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_FIELD_INDEX; + + typedef enum + { + SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_TIMESTAMP, + SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_SEVERITY, + SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_FIELDS + } SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_FIELD_INDEX; + + typedef enum + { + SKIN_TEMP_OVERNIGHT_MESG_TIMESTAMP, + SKIN_TEMP_OVERNIGHT_MESG_LOCAL_TIMESTAMP, + SKIN_TEMP_OVERNIGHT_MESG_AVERAGE_DEVIATION, + SKIN_TEMP_OVERNIGHT_MESG_AVERAGE_7_DAY_DEVIATION, + SKIN_TEMP_OVERNIGHT_MESG_NIGHTLY_VALUE, + SKIN_TEMP_OVERNIGHT_MESG_FIELDS + } SKIN_TEMP_OVERNIGHT_MESG_FIELD_INDEX; + + typedef enum + { + PAD_MESG_FIELDS + } PAD_MESG_FIELD_INDEX; + + typedef struct + { + FIT_FLOAT64 scale; + FIT_FLOAT64 offset; + FIT_UINT8 num; + FIT_UINT8 bits; + FIT_BOOL accumulate; + } FIELD_COMPONENT; + + typedef struct + { + FIT_SINT32 refFieldValue; + FIT_UINT8 refFieldNum; + } SUBFIELD_MAP; + + typedef struct + { + const SUBFIELD_MAP* maps; + const FIELD_COMPONENT* components; + std::string name; + std::string units; + FIT_FLOAT64 scale; + FIT_FLOAT64 offset; + FIT_UINT8 numMaps; + FIT_UINT16 numComponents; + FIT_UINT8 type; + } SUBFIELD; + + typedef struct + { + const FIELD_COMPONENT* components; + const SUBFIELD* subFields; + std::string name; + std::string units; + FIT_FLOAT64 scale; + FIT_FLOAT64 offset; + FIT_UINT16 numComponents; + FIT_UINT16 numSubFields; + FIT_UINT8 num; + FIT_UINT8 type; + FIT_BOOL isAccumulated; + Type profileType; + } FIELD; + + typedef struct + { + const FIELD* fields; + std::string name; + FIT_UINT16 num; + FIT_UINT16 numFields; + } MESG; + + static const MESG mesgs[MESGS]; + + static const Profile::MESG* GetMesg(const FIT_UINT16 num); + static const Profile::MESG* GetMesg(const std::string& name); + static const FIT_UINT16 GetFieldIndex(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum); + static const FIT_UINT16 GetFieldIndex(const std::string& mesgName, const std::string& fieldName); + static const Profile::FIELD* GetField(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum); + static const Profile::FIELD* GetField(const std::string& mesgName, const std::string& fieldName); + static const FIT_UINT16 GetSubFieldIndex(const std::string& mesgName, const std::string& fieldName, const std::string& subFieldName); + static const Profile::SUBFIELD* GetSubField(const FIT_UINT16 mesgNum, const FIT_UINT8 fieldNum, const FIT_UINT16 subFieldIndex); + static const Profile::SUBFIELD* GetSubField(const std::string& mesgName, const std::string& fieldName, const std::string& subFieldName); +}; + +} // namespace fit + +#endif // !defined(FIT_PROFILE_HPP) diff --git a/fit_protocol_validator.cpp b/fit_protocol_validator.cpp new file mode 100644 index 0000000..af22949 --- /dev/null +++ b/fit_protocol_validator.cpp @@ -0,0 +1,94 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_mesg.hpp" +#include "fit_mesg_definition.hpp" +#include "fit_protocol_validator.hpp" + +fit::ProtocolValidator::ProtocolValidator( ProtocolVersion version ) + : validator( nullptr ) +{ + switch ( version ) + { + case ProtocolVersion::V10: + validator = new V1Validator(); + break; + + case ProtocolVersion::V20: + default: + break; + } +} + +fit::ProtocolValidator::~ProtocolValidator() +{ + if ( nullptr != validator ) + { + delete validator; + } +} + +bool fit::ProtocolValidator::ValidateMesg( const Mesg& mesg ) +{ + if ( nullptr == validator ) return true; + return validator->ValidateMesg( mesg ); +} + +bool fit::ProtocolValidator::ValidateMesgDefn( const MesgDefinition& defn ) +{ + if ( nullptr == validator ) return true; + return validator->ValidateMesgDefn( defn ); +} + +bool fit::V1Validator::ValidateMesg( const Mesg& mesg ) +{ + if ( mesg.GetDeveloperFields().size() != 0 ) + { + return false; + } + + for ( FIT_UINT16 i = 0; i < mesg.GetNumFields(); i++ ) + { + const Field* fld = mesg.GetFieldByIndex( i ); + FIT_UINT8 typeNum = fld->GetType() & FIT_BASE_TYPE_NUM_MASK; + + // V2 introduces 64 bit types. + if ( typeNum > ( FIT_BASE_TYPE_BYTE & FIT_BASE_TYPE_NUM_MASK ) ) + { + return false; + } + } + + return true; +} + +bool fit::V1Validator::ValidateMesgDefn( const MesgDefinition& defn ) +{ + if ( defn.GetDevFields().size() != 0 ) + { + return false; + } + + for ( auto fld : defn.GetFields() ) + { + FIT_UINT8 typeNum = fld.GetType() & FIT_BASE_TYPE_NUM_MASK; + + // V2 introduces 64 bit types. + if ( typeNum > ( FIT_BASE_TYPE_BYTE & FIT_BASE_TYPE_NUM_MASK ) ) + { + return false; + } + } + + return true; +} + diff --git a/fit_protocol_validator.hpp b/fit_protocol_validator.hpp new file mode 100644 index 0000000..3c1b23a --- /dev/null +++ b/fit_protocol_validator.hpp @@ -0,0 +1,57 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(PROTOCOL_VALIDATOR_HPP) +#define PROTOCOL_VALIDATOR_HPP + +#include "fit.hpp" + +namespace fit +{ +class MesgDefinition; +class Mesg; + +class Validator +{ +public: + virtual ~Validator() {} + + virtual bool ValidateMesg( const Mesg& mesg ) = 0; + virtual bool ValidateMesgDefn( const MesgDefinition& defn ) = 0; +}; + +class ProtocolValidator + : public Validator +{ +public: + ProtocolValidator() = delete; + explicit ProtocolValidator( ProtocolVersion version ); + ~ProtocolValidator(); + + bool ValidateMesg( const Mesg& mesg ) override final; + bool ValidateMesgDefn( const MesgDefinition& defn ) override final; + +private: + Validator* validator; +}; + +class V1Validator + : public Validator +{ +public: + bool ValidateMesg( const Mesg& mesg ) override final; + bool ValidateMesgDefn( const MesgDefinition& defn ) override final; +}; + +} // namespace fit + +#endif // defined(PROTOCOL_VALIDATOR_HPP) diff --git a/fit_raw_bbi_mesg.hpp b/fit_raw_bbi_mesg.hpp new file mode 100644 index 0000000..83d4f8e --- /dev/null +++ b/fit_raw_bbi_mesg.hpp @@ -0,0 +1,280 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RAW_BBI_MESG_HPP) +#define FIT_RAW_BBI_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class RawBbiMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 Data = 1; + static const FIT_UINT8 Time = 2; + static const FIT_UINT8 Quality = 3; + static const FIT_UINT8 Gap = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + RawBbiMesg(void) : Mesg(Profile::MESG_RAW_BBI) + { + } + + RawBbiMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond resolution of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond resolution of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumData(void) const + { + return GetFieldNumValues(1, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of data field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDataValid(FIT_UINT8 index) const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns data field + // Comment: 1 bit for gap indicator, 1 bit for quality indicator, and 14 bits for Beat-to-Beat interval values in whole-integer millisecond resolution + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetData(FIT_UINT8 index) const + { + return GetFieldUINT16Value(1, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set data field + // Comment: 1 bit for gap indicator, 1 bit for quality indicator, and 14 bits for Beat-to-Beat interval values in whole-integer millisecond resolution + /////////////////////////////////////////////////////////////////////// + void SetData(FIT_UINT8 index, FIT_UINT16 data) + { + SetFieldUINT16Value(1, data, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTime(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time field + // Units: ms + // Comment: Array of millisecond times between beats + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTime(FIT_UINT8 index) const + { + return GetFieldUINT16Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time field + // Units: ms + // Comment: Array of millisecond times between beats + /////////////////////////////////////////////////////////////////////// + void SetTime(FIT_UINT8 index, FIT_UINT16 time) + { + SetFieldUINT16Value(2, time, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of quality + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumQuality(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of quality field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsQualityValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns quality field + // Comment: 1 = high confidence. 0 = low confidence. N/A when gap = 1 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetQuality(FIT_UINT8 index) const + { + return GetFieldUINT8Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set quality field + // Comment: 1 = high confidence. 0 = low confidence. N/A when gap = 1 + /////////////////////////////////////////////////////////////////////// + void SetQuality(FIT_UINT8 index, FIT_UINT8 quality) + { + SetFieldUINT8Value(3, quality, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of gap + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGap(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gap field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGapValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gap field + // Comment: 1 = gap (time represents ms gap length). 0 = BBI data + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGap(FIT_UINT8 index) const + { + return GetFieldUINT8Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gap field + // Comment: 1 = gap (time represents ms gap length). 0 = BBI data + /////////////////////////////////////////////////////////////////////// + void SetGap(FIT_UINT8 index, FIT_UINT8 gap) + { + SetFieldUINT8Value(4, gap, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_RAW_BBI_MESG_HPP) diff --git a/fit_raw_bbi_mesg_listener.hpp b/fit_raw_bbi_mesg_listener.hpp new file mode 100644 index 0000000..8c3aeae --- /dev/null +++ b/fit_raw_bbi_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RAW_BBI_MESG_LISTENER_HPP) +#define FIT_RAW_BBI_MESG_LISTENER_HPP + +#include "fit_raw_bbi_mesg.hpp" + +namespace fit +{ + +class RawBbiMesgListener +{ +public: + virtual ~RawBbiMesgListener() {} + virtual void OnMesg(RawBbiMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_RAW_BBI_MESG_LISTENER_HPP) diff --git a/fit_record_mesg.hpp b/fit_record_mesg.hpp new file mode 100644 index 0000000..7aae001 --- /dev/null +++ b/fit_record_mesg.hpp @@ -0,0 +1,2982 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RECORD_MESG_HPP) +#define FIT_RECORD_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class RecordMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 PositionLat = 0; + static const FIT_UINT8 PositionLong = 1; + static const FIT_UINT8 Altitude = 2; + static const FIT_UINT8 HeartRate = 3; + static const FIT_UINT8 Cadence = 4; + static const FIT_UINT8 Distance = 5; + static const FIT_UINT8 Speed = 6; + static const FIT_UINT8 Power = 7; + static const FIT_UINT8 CompressedSpeedDistance = 8; + static const FIT_UINT8 Grade = 9; + static const FIT_UINT8 Resistance = 10; + static const FIT_UINT8 TimeFromCourse = 11; + static const FIT_UINT8 CycleLength = 12; + static const FIT_UINT8 Temperature = 13; + static const FIT_UINT8 Speed1s = 17; + static const FIT_UINT8 Cycles = 18; + static const FIT_UINT8 TotalCycles = 19; + static const FIT_UINT8 CompressedAccumulatedPower = 28; + static const FIT_UINT8 AccumulatedPower = 29; + static const FIT_UINT8 LeftRightBalance = 30; + static const FIT_UINT8 GpsAccuracy = 31; + static const FIT_UINT8 VerticalSpeed = 32; + static const FIT_UINT8 Calories = 33; + static const FIT_UINT8 VerticalOscillation = 39; + static const FIT_UINT8 StanceTimePercent = 40; + static const FIT_UINT8 StanceTime = 41; + static const FIT_UINT8 ActivityType = 42; + static const FIT_UINT8 LeftTorqueEffectiveness = 43; + static const FIT_UINT8 RightTorqueEffectiveness = 44; + static const FIT_UINT8 LeftPedalSmoothness = 45; + static const FIT_UINT8 RightPedalSmoothness = 46; + static const FIT_UINT8 CombinedPedalSmoothness = 47; + static const FIT_UINT8 Time128 = 48; + static const FIT_UINT8 StrokeType = 49; + static const FIT_UINT8 Zone = 50; + static const FIT_UINT8 BallSpeed = 51; + static const FIT_UINT8 Cadence256 = 52; + static const FIT_UINT8 FractionalCadence = 53; + static const FIT_UINT8 TotalHemoglobinConc = 54; + static const FIT_UINT8 TotalHemoglobinConcMin = 55; + static const FIT_UINT8 TotalHemoglobinConcMax = 56; + static const FIT_UINT8 SaturatedHemoglobinPercent = 57; + static const FIT_UINT8 SaturatedHemoglobinPercentMin = 58; + static const FIT_UINT8 SaturatedHemoglobinPercentMax = 59; + static const FIT_UINT8 DeviceIndex = 62; + static const FIT_UINT8 LeftPco = 67; + static const FIT_UINT8 RightPco = 68; + static const FIT_UINT8 LeftPowerPhase = 69; + static const FIT_UINT8 LeftPowerPhasePeak = 70; + static const FIT_UINT8 RightPowerPhase = 71; + static const FIT_UINT8 RightPowerPhasePeak = 72; + static const FIT_UINT8 EnhancedSpeed = 73; + static const FIT_UINT8 EnhancedAltitude = 78; + static const FIT_UINT8 BatterySoc = 81; + static const FIT_UINT8 MotorPower = 82; + static const FIT_UINT8 VerticalRatio = 83; + static const FIT_UINT8 StanceTimeBalance = 84; + static const FIT_UINT8 StepLength = 85; + static const FIT_UINT8 CycleLength16 = 87; + static const FIT_UINT8 AbsolutePressure = 91; + static const FIT_UINT8 Depth = 92; + static const FIT_UINT8 NextStopDepth = 93; + static const FIT_UINT8 NextStopTime = 94; + static const FIT_UINT8 TimeToSurface = 95; + static const FIT_UINT8 NdlTime = 96; + static const FIT_UINT8 CnsLoad = 97; + static const FIT_UINT8 N2Load = 98; + static const FIT_UINT8 RespirationRate = 99; + static const FIT_UINT8 EnhancedRespirationRate = 108; + static const FIT_UINT8 Grit = 114; + static const FIT_UINT8 Flow = 115; + static const FIT_UINT8 CurrentStress = 116; + static const FIT_UINT8 EbikeTravelRange = 117; + static const FIT_UINT8 EbikeBatteryLevel = 118; + static const FIT_UINT8 EbikeAssistMode = 119; + static const FIT_UINT8 EbikeAssistLevelPercent = 120; + static const FIT_UINT8 AirTimeRemaining = 123; + static const FIT_UINT8 PressureSac = 124; + static const FIT_UINT8 VolumeSac = 125; + static const FIT_UINT8 Rmv = 126; + static const FIT_UINT8 AscentRate = 127; + static const FIT_UINT8 Po2 = 129; + static const FIT_UINT8 CoreTemperature = 139; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + RecordMesg(void) : Mesg(Profile::MESG_RECORD) + { + } + + RecordMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLatValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLat(void) const + { + return GetFieldSINT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLat(FIT_SINT32 positionLat) + { + SetFieldSINT32Value(0, positionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLongValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLong(void) const + { + return GetFieldSINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLong(FIT_SINT32 positionLong) + { + SetFieldSINT32Value(1, positionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAltitudeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAltitude(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAltitude(FIT_FLOAT32 altitude) + { + SetFieldFLOAT32Value(2, altitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeartRateValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHeartRate(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHeartRate(FIT_UINT8 heartRate) + { + SetFieldUINT8Value(3, heartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCadenceValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetCadence(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetCadence(FIT_UINT8 cadence) + { + SetFieldUINT8Value(4, cadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDistance(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDistance(FIT_FLOAT32 distance) + { + SetFieldFLOAT32Value(5, distance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeed(void) const + { + return GetFieldFLOAT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSpeed(FIT_FLOAT32 speed) + { + SetFieldFLOAT32Value(6, speed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPower(void) const + { + return GetFieldUINT16Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetPower(FIT_UINT16 power) + { + SetFieldUINT16Value(7, power, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of compressed_speed_distance + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCompressedSpeedDistance(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of compressed_speed_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCompressedSpeedDistanceValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns compressed_speed_distance field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetCompressedSpeedDistance(FIT_UINT8 index) const + { + return GetFieldBYTEValue(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set compressed_speed_distance field + /////////////////////////////////////////////////////////////////////// + void SetCompressedSpeedDistance(FIT_UINT8 index, FIT_BYTE compressedSpeedDistance) + { + SetFieldBYTEValue(8, compressedSpeedDistance, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGradeValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetGrade(void) const + { + return GetFieldFLOAT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetGrade(FIT_FLOAT32 grade) + { + SetFieldFLOAT32Value(9, grade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of resistance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsResistanceValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns resistance field + // Comment: Relative. 0 is none 254 is Max. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetResistance(void) const + { + return GetFieldUINT8Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set resistance field + // Comment: Relative. 0 is none 254 is Max. + /////////////////////////////////////////////////////////////////////// + void SetResistance(FIT_UINT8 resistance) + { + SetFieldUINT8Value(10, resistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_from_course field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeFromCourseValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_from_course field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeFromCourse(void) const + { + return GetFieldFLOAT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_from_course field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeFromCourse(FIT_FLOAT32 timeFromCourse) + { + SetFieldFLOAT32Value(11, timeFromCourse, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycle_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCycleLengthValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycle_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCycleLength(void) const + { + return GetFieldFLOAT32Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycle_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetCycleLength(FIT_FLOAT32 cycleLength) + { + SetFieldFLOAT32Value(12, cycleLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetTemperature(void) const + { + return GetFieldSINT8Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetTemperature(FIT_SINT8 temperature) + { + SetFieldSINT8Value(13, temperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of speed_1s + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSpeed1s(void) const + { + return GetFieldNumValues(17, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_1s field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeed1sValid(FIT_UINT8 index) const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed_1s field + // Units: m/s + // Comment: Speed at 1s intervals. Timestamp field indicates time of last array element. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeed1s(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(17, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_1s field + // Units: m/s + // Comment: Speed at 1s intervals. Timestamp field indicates time of last array element. + /////////////////////////////////////////////////////////////////////// + void SetSpeed1s(FIT_UINT8 index, FIT_FLOAT32 speed1s) + { + SetFieldFLOAT32Value(17, speed1s, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCyclesValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetCycles(void) const + { + return GetFieldUINT8Value(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + void SetCycles(FIT_UINT8 cycles) + { + SetFieldUINT8Value(18, cycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCyclesValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalCycles(void) const + { + return GetFieldUINT32Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalCycles(FIT_UINT32 totalCycles) + { + SetFieldUINT32Value(19, totalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of compressed_accumulated_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCompressedAccumulatedPowerValid() const + { + const Field* field = GetField(28); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns compressed_accumulated_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCompressedAccumulatedPower(void) const + { + return GetFieldUINT16Value(28, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set compressed_accumulated_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetCompressedAccumulatedPower(FIT_UINT16 compressedAccumulatedPower) + { + SetFieldUINT16Value(28, compressedAccumulatedPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accumulated_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccumulatedPowerValid() const + { + const Field* field = GetField(29); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns accumulated_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetAccumulatedPower(void) const + { + return GetFieldUINT32Value(29, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set accumulated_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetAccumulatedPower(FIT_UINT32 accumulatedPower) + { + SetFieldUINT32Value(29, accumulatedPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_right_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftRightBalanceValid() const + { + const Field* field = GetField(30); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_right_balance field + /////////////////////////////////////////////////////////////////////// + FIT_LEFT_RIGHT_BALANCE GetLeftRightBalance(void) const + { + return GetFieldUINT8Value(30, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_right_balance field + /////////////////////////////////////////////////////////////////////// + void SetLeftRightBalance(FIT_LEFT_RIGHT_BALANCE leftRightBalance) + { + SetFieldUINT8Value(30, leftRightBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gps_accuracy field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGpsAccuracyValid() const + { + const Field* field = GetField(31); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGpsAccuracy(void) const + { + return GetFieldUINT8Value(31, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetGpsAccuracy(FIT_UINT8 gpsAccuracy) + { + SetFieldUINT8Value(31, gpsAccuracy, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVerticalSpeedValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetVerticalSpeed(FIT_FLOAT32 verticalSpeed) + { + SetFieldFLOAT32Value(32, verticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCaloriesValid() const + { + const Field* field = GetField(33); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCalories(void) const + { + return GetFieldUINT16Value(33, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetCalories(FIT_UINT16 calories) + { + SetFieldUINT16Value(33, calories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of vertical_oscillation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVerticalOscillationValid() const + { + const Field* field = GetField(39); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns vertical_oscillation field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVerticalOscillation(void) const + { + return GetFieldFLOAT32Value(39, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set vertical_oscillation field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetVerticalOscillation(FIT_FLOAT32 verticalOscillation) + { + SetFieldFLOAT32Value(39, verticalOscillation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stance_time_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStanceTimePercentValid() const + { + const Field* field = GetField(40); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stance_time_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStanceTimePercent(void) const + { + return GetFieldFLOAT32Value(40, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stance_time_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetStanceTimePercent(FIT_FLOAT32 stanceTimePercent) + { + SetFieldFLOAT32Value(40, stanceTimePercent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stance_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStanceTimeValid() const + { + const Field* field = GetField(41); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stance_time field + // Units: ms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStanceTime(void) const + { + return GetFieldFLOAT32Value(41, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stance_time field + // Units: ms + /////////////////////////////////////////////////////////////////////// + void SetStanceTime(FIT_FLOAT32 stanceTime) + { + SetFieldFLOAT32Value(41, stanceTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityTypeValid() const + { + const Field* field = GetField(42); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_type field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_TYPE GetActivityType(void) const + { + return GetFieldENUMValue(42, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_type field + /////////////////////////////////////////////////////////////////////// + void SetActivityType(FIT_ACTIVITY_TYPE activityType) + { + SetFieldENUMValue(42, activityType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftTorqueEffectivenessValid() const + { + const Field* field = GetField(43); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLeftTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(43, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetLeftTorqueEffectiveness(FIT_FLOAT32 leftTorqueEffectiveness) + { + SetFieldFLOAT32Value(43, leftTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of right_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRightTorqueEffectivenessValid() const + { + const Field* field = GetField(44); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRightTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(44, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetRightTorqueEffectiveness(FIT_FLOAT32 rightTorqueEffectiveness) + { + SetFieldFLOAT32Value(44, rightTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftPedalSmoothnessValid() const + { + const Field* field = GetField(45); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLeftPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(45, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetLeftPedalSmoothness(FIT_FLOAT32 leftPedalSmoothness) + { + SetFieldFLOAT32Value(45, leftPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of right_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRightPedalSmoothnessValid() const + { + const Field* field = GetField(46); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRightPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(46, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetRightPedalSmoothness(FIT_FLOAT32 rightPedalSmoothness) + { + SetFieldFLOAT32Value(46, rightPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of combined_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCombinedPedalSmoothnessValid() const + { + const Field* field = GetField(47); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCombinedPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(47, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetCombinedPedalSmoothness(FIT_FLOAT32 combinedPedalSmoothness) + { + SetFieldFLOAT32Value(47, combinedPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time128 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTime128Valid() const + { + const Field* field = GetField(48); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time128 field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTime128(void) const + { + return GetFieldFLOAT32Value(48, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time128 field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTime128(FIT_FLOAT32 time128) + { + SetFieldFLOAT32Value(48, time128, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stroke_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStrokeTypeValid() const + { + const Field* field = GetField(49); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stroke_type field + /////////////////////////////////////////////////////////////////////// + FIT_STROKE_TYPE GetStrokeType(void) const + { + return GetFieldENUMValue(49, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stroke_type field + /////////////////////////////////////////////////////////////////////// + void SetStrokeType(FIT_STROKE_TYPE strokeType) + { + SetFieldENUMValue(49, strokeType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsZoneValid() const + { + const Field* field = GetField(50); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns zone field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetZone(void) const + { + return GetFieldUINT8Value(50, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set zone field + /////////////////////////////////////////////////////////////////////// + void SetZone(FIT_UINT8 zone) + { + SetFieldUINT8Value(50, zone, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ball_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBallSpeedValid() const + { + const Field* field = GetField(51); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ball_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBallSpeed(void) const + { + return GetFieldFLOAT32Value(51, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ball_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetBallSpeed(FIT_FLOAT32 ballSpeed) + { + SetFieldFLOAT32Value(51, ballSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cadence256 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCadence256Valid() const + { + const Field* field = GetField(52); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cadence256 field + // Units: rpm + // Comment: Log cadence and fractional cadence for backwards compatability + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCadence256(void) const + { + return GetFieldFLOAT32Value(52, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cadence256 field + // Units: rpm + // Comment: Log cadence and fractional cadence for backwards compatability + /////////////////////////////////////////////////////////////////////// + void SetCadence256(FIT_FLOAT32 cadence256) + { + SetFieldFLOAT32Value(52, cadence256, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFractionalCadenceValid() const + { + const Field* field = GetField(53); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fractional_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFractionalCadence(void) const + { + return GetFieldFLOAT32Value(53, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fractional_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetFractionalCadence(FIT_FLOAT32 fractionalCadence) + { + SetFieldFLOAT32Value(53, fractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalHemoglobinConcValid() const + { + const Field* field = GetField(54); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_hemoglobin_conc field + // Units: g/dL + // Comment: Total saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalHemoglobinConc(void) const + { + return GetFieldFLOAT32Value(54, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_hemoglobin_conc field + // Units: g/dL + // Comment: Total saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetTotalHemoglobinConc(FIT_FLOAT32 totalHemoglobinConc) + { + SetFieldFLOAT32Value(54, totalHemoglobinConc, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_hemoglobin_conc_min field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalHemoglobinConcMinValid() const + { + const Field* field = GetField(55); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_hemoglobin_conc_min field + // Units: g/dL + // Comment: Min saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalHemoglobinConcMin(void) const + { + return GetFieldFLOAT32Value(55, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_hemoglobin_conc_min field + // Units: g/dL + // Comment: Min saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetTotalHemoglobinConcMin(FIT_FLOAT32 totalHemoglobinConcMin) + { + SetFieldFLOAT32Value(55, totalHemoglobinConcMin, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_hemoglobin_conc_max field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalHemoglobinConcMaxValid() const + { + const Field* field = GetField(56); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_hemoglobin_conc_max field + // Units: g/dL + // Comment: Max saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalHemoglobinConcMax(void) const + { + return GetFieldFLOAT32Value(56, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_hemoglobin_conc_max field + // Units: g/dL + // Comment: Max saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetTotalHemoglobinConcMax(FIT_FLOAT32 totalHemoglobinConcMax) + { + SetFieldFLOAT32Value(56, totalHemoglobinConcMax, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSaturatedHemoglobinPercentValid() const + { + const Field* field = GetField(57); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns saturated_hemoglobin_percent field + // Units: % + // Comment: Percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSaturatedHemoglobinPercent(void) const + { + return GetFieldFLOAT32Value(57, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set saturated_hemoglobin_percent field + // Units: % + // Comment: Percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetSaturatedHemoglobinPercent(FIT_FLOAT32 saturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(57, saturatedHemoglobinPercent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of saturated_hemoglobin_percent_min field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSaturatedHemoglobinPercentMinValid() const + { + const Field* field = GetField(58); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns saturated_hemoglobin_percent_min field + // Units: % + // Comment: Min percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSaturatedHemoglobinPercentMin(void) const + { + return GetFieldFLOAT32Value(58, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set saturated_hemoglobin_percent_min field + // Units: % + // Comment: Min percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetSaturatedHemoglobinPercentMin(FIT_FLOAT32 saturatedHemoglobinPercentMin) + { + SetFieldFLOAT32Value(58, saturatedHemoglobinPercentMin, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of saturated_hemoglobin_percent_max field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSaturatedHemoglobinPercentMaxValid() const + { + const Field* field = GetField(59); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns saturated_hemoglobin_percent_max field + // Units: % + // Comment: Max percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSaturatedHemoglobinPercentMax(void) const + { + return GetFieldFLOAT32Value(59, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set saturated_hemoglobin_percent_max field + // Units: % + // Comment: Max percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetSaturatedHemoglobinPercentMax(FIT_FLOAT32 saturatedHemoglobinPercentMax) + { + SetFieldFLOAT32Value(59, saturatedHemoglobinPercentMax, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIndexValid() const + { + const Field* field = GetField(62); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_index field + /////////////////////////////////////////////////////////////////////// + FIT_DEVICE_INDEX GetDeviceIndex(void) const + { + return GetFieldUINT8Value(62, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_index field + /////////////////////////////////////////////////////////////////////// + void SetDeviceIndex(FIT_DEVICE_INDEX deviceIndex) + { + SetFieldUINT8Value(62, deviceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftPcoValid() const + { + const Field* field = GetField(67); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_pco field + // Units: mm + // Comment: Left platform center offset + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetLeftPco(void) const + { + return GetFieldSINT8Value(67, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_pco field + // Units: mm + // Comment: Left platform center offset + /////////////////////////////////////////////////////////////////////// + void SetLeftPco(FIT_SINT8 leftPco) + { + SetFieldSINT8Value(67, leftPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of right_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRightPcoValid() const + { + const Field* field = GetField(68); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns right_pco field + // Units: mm + // Comment: Right platform center offset + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetRightPco(void) const + { + return GetFieldSINT8Value(68, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set right_pco field + // Units: mm + // Comment: Right platform center offset + /////////////////////////////////////////////////////////////////////// + void SetRightPco(FIT_SINT8 rightPco) + { + SetFieldSINT8Value(68, rightPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of left_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeftPowerPhase(void) const + { + return GetFieldNumValues(69, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(69); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_power_phase field + // Units: degrees + // Comment: Left power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLeftPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(69, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_power_phase field + // Units: degrees + // Comment: Left power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetLeftPowerPhase(FIT_UINT8 index, FIT_FLOAT32 leftPowerPhase) + { + SetFieldFLOAT32Value(69, leftPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of left_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeftPowerPhasePeak(void) const + { + return GetFieldNumValues(70, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(70); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_power_phase_peak field + // Units: degrees + // Comment: Left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLeftPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(70, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_power_phase_peak field + // Units: degrees + // Comment: Left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetLeftPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 leftPowerPhasePeak) + { + SetFieldFLOAT32Value(70, leftPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of right_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumRightPowerPhase(void) const + { + return GetFieldNumValues(71, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of right_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRightPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(71); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns right_power_phase field + // Units: degrees + // Comment: Right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRightPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(71, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set right_power_phase field + // Units: degrees + // Comment: Right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetRightPowerPhase(FIT_UINT8 index, FIT_FLOAT32 rightPowerPhase) + { + SetFieldFLOAT32Value(71, rightPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of right_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumRightPowerPhasePeak(void) const + { + return GetFieldNumValues(72, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of right_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRightPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(72); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns right_power_phase_peak field + // Units: degrees + // Comment: Right power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRightPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(72, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set right_power_phase_peak field + // Units: degrees + // Comment: Right power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetRightPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 rightPowerPhasePeak) + { + SetFieldFLOAT32Value(72, rightPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedSpeedValid() const + { + const Field* field = GetField(73); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedSpeed(void) const + { + return GetFieldFLOAT32Value(73, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetEnhancedSpeed(FIT_FLOAT32 enhancedSpeed) + { + SetFieldFLOAT32Value(73, enhancedSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAltitudeValid() const + { + const Field* field = GetField(78); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAltitude(void) const + { + return GetFieldFLOAT32Value(78, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAltitude(FIT_FLOAT32 enhancedAltitude) + { + SetFieldFLOAT32Value(78, enhancedAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of battery_soc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBatterySocValid() const + { + const Field* field = GetField(81); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns battery_soc field + // Units: percent + // Comment: lev battery state of charge + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBatterySoc(void) const + { + return GetFieldFLOAT32Value(81, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set battery_soc field + // Units: percent + // Comment: lev battery state of charge + /////////////////////////////////////////////////////////////////////// + void SetBatterySoc(FIT_FLOAT32 batterySoc) + { + SetFieldFLOAT32Value(81, batterySoc, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of motor_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMotorPowerValid() const + { + const Field* field = GetField(82); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns motor_power field + // Units: watts + // Comment: lev motor power + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMotorPower(void) const + { + return GetFieldUINT16Value(82, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set motor_power field + // Units: watts + // Comment: lev motor power + /////////////////////////////////////////////////////////////////////// + void SetMotorPower(FIT_UINT16 motorPower) + { + SetFieldUINT16Value(82, motorPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of vertical_ratio field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVerticalRatioValid() const + { + const Field* field = GetField(83); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns vertical_ratio field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVerticalRatio(void) const + { + return GetFieldFLOAT32Value(83, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set vertical_ratio field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetVerticalRatio(FIT_FLOAT32 verticalRatio) + { + SetFieldFLOAT32Value(83, verticalRatio, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stance_time_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStanceTimeBalanceValid() const + { + const Field* field = GetField(84); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stance_time_balance field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStanceTimeBalance(void) const + { + return GetFieldFLOAT32Value(84, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stance_time_balance field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetStanceTimeBalance(FIT_FLOAT32 stanceTimeBalance) + { + SetFieldFLOAT32Value(84, stanceTimeBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of step_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStepLengthValid() const + { + const Field* field = GetField(85); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns step_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStepLength(void) const + { + return GetFieldFLOAT32Value(85, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set step_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetStepLength(FIT_FLOAT32 stepLength) + { + SetFieldFLOAT32Value(85, stepLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cycle_length16 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCycleLength16Valid() const + { + const Field* field = GetField(87); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cycle_length16 field + // Units: m + // Comment: Supports larger cycle sizes needed for paddlesports. Max cycle size: 655.35 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCycleLength16(void) const + { + return GetFieldFLOAT32Value(87, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cycle_length16 field + // Units: m + // Comment: Supports larger cycle sizes needed for paddlesports. Max cycle size: 655.35 + /////////////////////////////////////////////////////////////////////// + void SetCycleLength16(FIT_FLOAT32 cycleLength16) + { + SetFieldFLOAT32Value(87, cycleLength16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of absolute_pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAbsolutePressureValid() const + { + const Field* field = GetField(91); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns absolute_pressure field + // Units: Pa + // Comment: Includes atmospheric pressure + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetAbsolutePressure(void) const + { + return GetFieldUINT32Value(91, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set absolute_pressure field + // Units: Pa + // Comment: Includes atmospheric pressure + /////////////////////////////////////////////////////////////////////// + void SetAbsolutePressure(FIT_UINT32 absolutePressure) + { + SetFieldUINT32Value(91, absolutePressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDepthValid() const + { + const Field* field = GetField(92); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDepth(void) const + { + return GetFieldFLOAT32Value(92, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetDepth(FIT_FLOAT32 depth) + { + SetFieldFLOAT32Value(92, depth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of next_stop_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNextStopDepthValid() const + { + const Field* field = GetField(93); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns next_stop_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetNextStopDepth(void) const + { + return GetFieldFLOAT32Value(93, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set next_stop_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetNextStopDepth(FIT_FLOAT32 nextStopDepth) + { + SetFieldFLOAT32Value(93, nextStopDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of next_stop_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNextStopTimeValid() const + { + const Field* field = GetField(94); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns next_stop_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetNextStopTime(void) const + { + return GetFieldUINT32Value(94, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set next_stop_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetNextStopTime(FIT_UINT32 nextStopTime) + { + SetFieldUINT32Value(94, nextStopTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_to_surface field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeToSurfaceValid() const + { + const Field* field = GetField(95); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_to_surface field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTimeToSurface(void) const + { + return GetFieldUINT32Value(95, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_to_surface field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeToSurface(FIT_UINT32 timeToSurface) + { + SetFieldUINT32Value(95, timeToSurface, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ndl_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNdlTimeValid() const + { + const Field* field = GetField(96); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ndl_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetNdlTime(void) const + { + return GetFieldUINT32Value(96, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ndl_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetNdlTime(FIT_UINT32 ndlTime) + { + SetFieldUINT32Value(96, ndlTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cns_load field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCnsLoadValid() const + { + const Field* field = GetField(97); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cns_load field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetCnsLoad(void) const + { + return GetFieldUINT8Value(97, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cns_load field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetCnsLoad(FIT_UINT8 cnsLoad) + { + SetFieldUINT8Value(97, cnsLoad, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of n2_load field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsN2LoadValid() const + { + const Field* field = GetField(98); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns n2_load field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetN2Load(void) const + { + return GetFieldUINT16Value(98, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set n2_load field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetN2Load(FIT_UINT16 n2Load) + { + SetFieldUINT16Value(98, n2Load, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRespirationRateValid() const + { + const Field* field = GetField(99); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns respiration_rate field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRespirationRate(void) const + { + return GetFieldUINT8Value(99, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set respiration_rate field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetRespirationRate(FIT_UINT8 respirationRate) + { + SetFieldUINT8Value(99, respirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedRespirationRateValid() const + { + const Field* field = GetField(108); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedRespirationRate(void) const + { + return GetFieldFLOAT32Value(108, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedRespirationRate(FIT_FLOAT32 enhancedRespirationRate) + { + SetFieldFLOAT32Value(108, enhancedRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGritValid() const + { + const Field* field = GetField(114); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns grit field + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetGrit(void) const + { + return GetFieldFLOAT32Value(114, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set grit field + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetGrit(FIT_FLOAT32 grit) + { + SetFieldFLOAT32Value(114, grit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFlowValid() const + { + const Field* field = GetField(115); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns flow field + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFlow(void) const + { + return GetFieldFLOAT32Value(115, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set flow field + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetFlow(FIT_FLOAT32 flow) + { + SetFieldFLOAT32Value(115, flow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of current_stress field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCurrentStressValid() const + { + const Field* field = GetField(116); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns current_stress field + // Comment: Current Stress value + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCurrentStress(void) const + { + return GetFieldFLOAT32Value(116, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set current_stress field + // Comment: Current Stress value + /////////////////////////////////////////////////////////////////////// + void SetCurrentStress(FIT_FLOAT32 currentStress) + { + SetFieldFLOAT32Value(116, currentStress, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ebike_travel_range field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEbikeTravelRangeValid() const + { + const Field* field = GetField(117); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ebike_travel_range field + // Units: km + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetEbikeTravelRange(void) const + { + return GetFieldUINT16Value(117, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ebike_travel_range field + // Units: km + /////////////////////////////////////////////////////////////////////// + void SetEbikeTravelRange(FIT_UINT16 ebikeTravelRange) + { + SetFieldUINT16Value(117, ebikeTravelRange, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ebike_battery_level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEbikeBatteryLevelValid() const + { + const Field* field = GetField(118); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ebike_battery_level field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEbikeBatteryLevel(void) const + { + return GetFieldUINT8Value(118, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ebike_battery_level field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetEbikeBatteryLevel(FIT_UINT8 ebikeBatteryLevel) + { + SetFieldUINT8Value(118, ebikeBatteryLevel, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ebike_assist_mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEbikeAssistModeValid() const + { + const Field* field = GetField(119); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ebike_assist_mode field + // Units: depends on sensor + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEbikeAssistMode(void) const + { + return GetFieldUINT8Value(119, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ebike_assist_mode field + // Units: depends on sensor + /////////////////////////////////////////////////////////////////////// + void SetEbikeAssistMode(FIT_UINT8 ebikeAssistMode) + { + SetFieldUINT8Value(119, ebikeAssistMode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ebike_assist_level_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEbikeAssistLevelPercentValid() const + { + const Field* field = GetField(120); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ebike_assist_level_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEbikeAssistLevelPercent(void) const + { + return GetFieldUINT8Value(120, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ebike_assist_level_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetEbikeAssistLevelPercent(FIT_UINT8 ebikeAssistLevelPercent) + { + SetFieldUINT8Value(120, ebikeAssistLevelPercent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of air_time_remaining field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAirTimeRemainingValid() const + { + const Field* field = GetField(123); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns air_time_remaining field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetAirTimeRemaining(void) const + { + return GetFieldUINT32Value(123, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set air_time_remaining field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetAirTimeRemaining(FIT_UINT32 airTimeRemaining) + { + SetFieldUINT32Value(123, airTimeRemaining, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pressure_sac field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPressureSacValid() const + { + const Field* field = GetField(124); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pressure_sac field + // Units: bar/min + // Comment: Pressure-based surface air consumption + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPressureSac(void) const + { + return GetFieldFLOAT32Value(124, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pressure_sac field + // Units: bar/min + // Comment: Pressure-based surface air consumption + /////////////////////////////////////////////////////////////////////// + void SetPressureSac(FIT_FLOAT32 pressureSac) + { + SetFieldFLOAT32Value(124, pressureSac, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of volume_sac field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVolumeSacValid() const + { + const Field* field = GetField(125); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns volume_sac field + // Units: L/min + // Comment: Volumetric surface air consumption + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVolumeSac(void) const + { + return GetFieldFLOAT32Value(125, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set volume_sac field + // Units: L/min + // Comment: Volumetric surface air consumption + /////////////////////////////////////////////////////////////////////// + void SetVolumeSac(FIT_FLOAT32 volumeSac) + { + SetFieldFLOAT32Value(125, volumeSac, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rmv field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRmvValid() const + { + const Field* field = GetField(126); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rmv field + // Units: L/min + // Comment: Respiratory minute volume + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRmv(void) const + { + return GetFieldFLOAT32Value(126, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rmv field + // Units: L/min + // Comment: Respiratory minute volume + /////////////////////////////////////////////////////////////////////// + void SetRmv(FIT_FLOAT32 rmv) + { + SetFieldFLOAT32Value(126, rmv, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of ascent_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAscentRateValid() const + { + const Field* field = GetField(127); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns ascent_rate field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAscentRate(void) const + { + return GetFieldFLOAT32Value(127, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set ascent_rate field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAscentRate(FIT_FLOAT32 ascentRate) + { + SetFieldFLOAT32Value(127, ascentRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of po2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPo2Valid() const + { + const Field* field = GetField(129); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns po2 field + // Units: percent + // Comment: Current partial pressure of oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPo2(void) const + { + return GetFieldFLOAT32Value(129, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set po2 field + // Units: percent + // Comment: Current partial pressure of oxygen + /////////////////////////////////////////////////////////////////////// + void SetPo2(FIT_FLOAT32 po2) + { + SetFieldFLOAT32Value(129, po2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCoreTemperatureValid() const + { + const Field* field = GetField(139); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCoreTemperature(void) const + { + return GetFieldFLOAT32Value(139, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetCoreTemperature(FIT_FLOAT32 coreTemperature) + { + SetFieldFLOAT32Value(139, coreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_RECORD_MESG_HPP) diff --git a/fit_record_mesg_listener.hpp b/fit_record_mesg_listener.hpp new file mode 100644 index 0000000..65418fe --- /dev/null +++ b/fit_record_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RECORD_MESG_LISTENER_HPP) +#define FIT_RECORD_MESG_LISTENER_HPP + +#include "fit_record_mesg.hpp" + +namespace fit +{ + +class RecordMesgListener +{ +public: + virtual ~RecordMesgListener() {} + virtual void OnMesg(RecordMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_RECORD_MESG_LISTENER_HPP) diff --git a/fit_respiration_rate_mesg.hpp b/fit_respiration_rate_mesg.hpp new file mode 100644 index 0000000..5906a88 --- /dev/null +++ b/fit_respiration_rate_mesg.hpp @@ -0,0 +1,110 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RESPIRATION_RATE_MESG_HPP) +#define FIT_RESPIRATION_RATE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class RespirationRateMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 RespirationRate = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + RespirationRateMesg(void) : Mesg(Profile::MESG_RESPIRATION_RATE) + { + } + + RespirationRateMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRespirationRateValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns respiration_rate field + // Units: breaths/min + // Comment: Breaths * 100 /min, -300 indicates invalid, -200 indicates large motion, -100 indicates off wrist + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRespirationRate(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set respiration_rate field + // Units: breaths/min + // Comment: Breaths * 100 /min, -300 indicates invalid, -200 indicates large motion, -100 indicates off wrist + /////////////////////////////////////////////////////////////////////// + void SetRespirationRate(FIT_FLOAT32 respirationRate) + { + SetFieldFLOAT32Value(0, respirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_RESPIRATION_RATE_MESG_HPP) diff --git a/fit_respiration_rate_mesg_listener.hpp b/fit_respiration_rate_mesg_listener.hpp new file mode 100644 index 0000000..44a90ba --- /dev/null +++ b/fit_respiration_rate_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RESPIRATION_RATE_MESG_LISTENER_HPP) +#define FIT_RESPIRATION_RATE_MESG_LISTENER_HPP + +#include "fit_respiration_rate_mesg.hpp" + +namespace fit +{ + +class RespirationRateMesgListener +{ +public: + virtual ~RespirationRateMesgListener() {} + virtual void OnMesg(RespirationRateMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_RESPIRATION_RATE_MESG_LISTENER_HPP) diff --git a/fit_runtime_exception.hpp b/fit_runtime_exception.hpp new file mode 100644 index 0000000..c96f762 --- /dev/null +++ b/fit_runtime_exception.hpp @@ -0,0 +1,33 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_RUNTIME_EXCEPTION_HPP) +#define FIT_RUNTIME_EXCEPTION_HPP + +#include +#include + +namespace fit +{ + +class RuntimeException : public std::runtime_error +{ +public: + RuntimeException(const std::string& msg = "") + : runtime_error(msg) + { + } +}; + +} // namespace fit + +#endif // !defined(FIT_RUNTIME_EXCEPTION_HPP) diff --git a/fit_schedule_mesg.hpp b/fit_schedule_mesg.hpp new file mode 100644 index 0000000..a5f464e --- /dev/null +++ b/fit_schedule_mesg.hpp @@ -0,0 +1,350 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SCHEDULE_MESG_HPP) +#define FIT_SCHEDULE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ScheduleMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Manufacturer = 0; + static const FIT_UINT8 Product = 1; + static const FIT_UINT8 SerialNumber = 2; + static const FIT_UINT8 TimeCreated = 3; + static const FIT_UINT8 Completed = 4; + static const FIT_UINT8 Type = 5; + static const FIT_UINT8 ScheduledTime = 6; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ScheduleMesg(void) : Mesg(Profile::MESG_SCHEDULE) + { + } + + ScheduleMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturer(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + void SetManufacturer(FIT_MANUFACTURER manufacturer) + { + SetFieldUINT16Value(0, manufacturer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProduct(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + void SetProduct(FIT_UINT16 product) + { + SetFieldUINT16Value(1, product, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of favero_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFaveroProductValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns favero_product field + /////////////////////////////////////////////////////////////////////// + FIT_FAVERO_PRODUCT GetFaveroProduct(void) const + { + return GetFieldUINT16Value(1, 0, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set favero_product field + /////////////////////////////////////////////////////////////////////// + void SetFaveroProduct(FIT_FAVERO_PRODUCT faveroProduct) + { + SetFieldUINT16Value(1, faveroProduct, 0, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of garmin_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGarminProductValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns garmin_product field + /////////////////////////////////////////////////////////////////////// + FIT_GARMIN_PRODUCT GetGarminProduct(void) const + { + return GetFieldUINT16Value(1, 0, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set garmin_product field + /////////////////////////////////////////////////////////////////////// + void SetGarminProduct(FIT_GARMIN_PRODUCT garminProduct) + { + SetFieldUINT16Value(1, garminProduct, 0, (FIT_UINT16) Profile::SCHEDULE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of serial_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSerialNumberValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns serial_number field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32Z GetSerialNumber(void) const + { + return GetFieldUINT32ZValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set serial_number field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + void SetSerialNumber(FIT_UINT32Z serialNumber) + { + SetFieldUINT32ZValue(2, serialNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_created field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeCreatedValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_created field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimeCreated(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_created field + // Comment: Corresponds to file_id of scheduled workout / course. + /////////////////////////////////////////////////////////////////////// + void SetTimeCreated(FIT_DATE_TIME timeCreated) + { + SetFieldUINT32Value(3, timeCreated, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of completed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCompletedValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns completed field + // Comment: TRUE if this activity has been started + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetCompleted(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set completed field + // Comment: TRUE if this activity has been started + /////////////////////////////////////////////////////////////////////// + void SetCompleted(FIT_BOOL completed) + { + SetFieldENUMValue(4, completed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_SCHEDULE GetType(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_SCHEDULE type) + { + SetFieldENUMValue(5, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of scheduled_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsScheduledTimeValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns scheduled_time field + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DATE_TIME GetScheduledTime(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set scheduled_time field + /////////////////////////////////////////////////////////////////////// + void SetScheduledTime(FIT_LOCAL_DATE_TIME scheduledTime) + { + SetFieldUINT32Value(6, scheduledTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SCHEDULE_MESG_HPP) diff --git a/fit_schedule_mesg_listener.hpp b/fit_schedule_mesg_listener.hpp new file mode 100644 index 0000000..132e35d --- /dev/null +++ b/fit_schedule_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SCHEDULE_MESG_LISTENER_HPP) +#define FIT_SCHEDULE_MESG_LISTENER_HPP + +#include "fit_schedule_mesg.hpp" + +namespace fit +{ + +class ScheduleMesgListener +{ +public: + virtual ~ScheduleMesgListener() {} + virtual void OnMesg(ScheduleMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SCHEDULE_MESG_LISTENER_HPP) diff --git a/fit_sdm_profile_mesg.hpp b/fit_sdm_profile_mesg.hpp new file mode 100644 index 0000000..f4469cc --- /dev/null +++ b/fit_sdm_profile_mesg.hpp @@ -0,0 +1,306 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SDM_PROFILE_MESG_HPP) +#define FIT_SDM_PROFILE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SdmProfileMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Enabled = 0; + static const FIT_UINT8 SdmAntId = 1; + static const FIT_UINT8 SdmCalFactor = 2; + static const FIT_UINT8 Odometer = 3; + static const FIT_UINT8 SpeedSource = 4; + static const FIT_UINT8 SdmAntIdTransType = 5; + static const FIT_UINT8 OdometerRollover = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SdmProfileMesg(void) : Mesg(Profile::MESG_SDM_PROFILE) + { + } + + SdmProfileMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(0, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sdm_ant_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSdmAntIdValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sdm_ant_id field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16Z GetSdmAntId(void) const + { + return GetFieldUINT16ZValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sdm_ant_id field + /////////////////////////////////////////////////////////////////////// + void SetSdmAntId(FIT_UINT16Z sdmAntId) + { + SetFieldUINT16ZValue(1, sdmAntId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sdm_cal_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSdmCalFactorValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sdm_cal_factor field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSdmCalFactor(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sdm_cal_factor field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetSdmCalFactor(FIT_FLOAT32 sdmCalFactor) + { + SetFieldFLOAT32Value(2, sdmCalFactor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of odometer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOdometerValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns odometer field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetOdometer(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set odometer field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetOdometer(FIT_FLOAT32 odometer) + { + SetFieldFLOAT32Value(3, odometer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_source field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedSourceValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed_source field + // Comment: Use footpod for speed source instead of GPS + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetSpeedSource(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_source field + // Comment: Use footpod for speed source instead of GPS + /////////////////////////////////////////////////////////////////////// + void SetSpeedSource(FIT_BOOL speedSource) + { + SetFieldENUMValue(4, speedSource, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sdm_ant_id_trans_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSdmAntIdTransTypeValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sdm_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8Z GetSdmAntIdTransType(void) const + { + return GetFieldUINT8ZValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sdm_ant_id_trans_type field + /////////////////////////////////////////////////////////////////////// + void SetSdmAntIdTransType(FIT_UINT8Z sdmAntIdTransType) + { + SetFieldUINT8ZValue(5, sdmAntIdTransType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of odometer_rollover field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOdometerRolloverValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns odometer_rollover field + // Comment: Rollover counter that can be used to extend the odometer + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetOdometerRollover(void) const + { + return GetFieldUINT8Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set odometer_rollover field + // Comment: Rollover counter that can be used to extend the odometer + /////////////////////////////////////////////////////////////////////// + void SetOdometerRollover(FIT_UINT8 odometerRollover) + { + SetFieldUINT8Value(7, odometerRollover, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SDM_PROFILE_MESG_HPP) diff --git a/fit_sdm_profile_mesg_listener.hpp b/fit_sdm_profile_mesg_listener.hpp new file mode 100644 index 0000000..240ed39 --- /dev/null +++ b/fit_sdm_profile_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SDM_PROFILE_MESG_LISTENER_HPP) +#define FIT_SDM_PROFILE_MESG_LISTENER_HPP + +#include "fit_sdm_profile_mesg.hpp" + +namespace fit +{ + +class SdmProfileMesgListener +{ +public: + virtual ~SdmProfileMesgListener() {} + virtual void OnMesg(SdmProfileMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SDM_PROFILE_MESG_LISTENER_HPP) diff --git a/fit_segment_file_mesg.hpp b/fit_segment_file_mesg.hpp new file mode 100644 index 0000000..665b23a --- /dev/null +++ b/fit_segment_file_mesg.hpp @@ -0,0 +1,378 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_FILE_MESG_HPP) +#define FIT_SEGMENT_FILE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SegmentFileMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 FileUuid = 1; + static const FIT_UINT8 Enabled = 3; + static const FIT_UINT8 UserProfilePrimaryKey = 4; + static const FIT_UINT8 LeaderType = 7; + static const FIT_UINT8 LeaderGroupPrimaryKey = 8; + static const FIT_UINT8 LeaderActivityId = 9; + static const FIT_UINT8 LeaderActivityIdString = 10; + static const FIT_UINT8 DefaultRaceLeader = 11; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SegmentFileMesg(void) : Mesg(Profile::MESG_SEGMENT_FILE) + { + } + + SegmentFileMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of file_uuid field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFileUuidValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns file_uuid field + // Comment: UUID of the segment file + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetFileUuid(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set file_uuid field + // Comment: UUID of the segment file + /////////////////////////////////////////////////////////////////////// + void SetFileUuid(FIT_WSTRING fileUuid) + { + SetFieldSTRINGValue(1, fileUuid, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + // Comment: Enabled state of the segment file + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + // Comment: Enabled state of the segment file + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(3, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of user_profile_primary_key field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUserProfilePrimaryKeyValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns user_profile_primary_key field + // Comment: Primary key of the user that created the segment file + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetUserProfilePrimaryKey(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set user_profile_primary_key field + // Comment: Primary key of the user that created the segment file + /////////////////////////////////////////////////////////////////////// + void SetUserProfilePrimaryKey(FIT_UINT32 userProfilePrimaryKey) + { + SetFieldUINT32Value(4, userProfilePrimaryKey, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of leader_type + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeaderType(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of leader_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeaderTypeValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns leader_type field + // Comment: Leader type of each leader in the segment file + /////////////////////////////////////////////////////////////////////// + FIT_SEGMENT_LEADERBOARD_TYPE GetLeaderType(FIT_UINT8 index) const + { + return GetFieldENUMValue(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set leader_type field + // Comment: Leader type of each leader in the segment file + /////////////////////////////////////////////////////////////////////// + void SetLeaderType(FIT_UINT8 index, FIT_SEGMENT_LEADERBOARD_TYPE leaderType) + { + SetFieldENUMValue(7, leaderType, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of leader_group_primary_key + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeaderGroupPrimaryKey(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of leader_group_primary_key field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeaderGroupPrimaryKeyValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns leader_group_primary_key field + // Comment: Group primary key of each leader in the segment file + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetLeaderGroupPrimaryKey(FIT_UINT8 index) const + { + return GetFieldUINT32Value(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set leader_group_primary_key field + // Comment: Group primary key of each leader in the segment file + /////////////////////////////////////////////////////////////////////// + void SetLeaderGroupPrimaryKey(FIT_UINT8 index, FIT_UINT32 leaderGroupPrimaryKey) + { + SetFieldUINT32Value(8, leaderGroupPrimaryKey, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of leader_activity_id + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeaderActivityId(void) const + { + return GetFieldNumValues(9, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of leader_activity_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeaderActivityIdValid(FIT_UINT8 index) const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns leader_activity_id field + // Comment: Activity ID of each leader in the segment file + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetLeaderActivityId(FIT_UINT8 index) const + { + return GetFieldUINT32Value(9, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set leader_activity_id field + // Comment: Activity ID of each leader in the segment file + /////////////////////////////////////////////////////////////////////// + void SetLeaderActivityId(FIT_UINT8 index, FIT_UINT32 leaderActivityId) + { + SetFieldUINT32Value(9, leaderActivityId, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of leader_activity_id_string + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeaderActivityIdString(void) const + { + return GetFieldNumValues(10, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of leader_activity_id_string field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeaderActivityIdStringValid(FIT_UINT8 index) const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns leader_activity_id_string field + // Comment: String version of the activity ID of each leader in the segment file. 21 characters long for each ID, express in decimal + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetLeaderActivityIdString(FIT_UINT8 index) const + { + return GetFieldSTRINGValue(10, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set leader_activity_id_string field + // Comment: String version of the activity ID of each leader in the segment file. 21 characters long for each ID, express in decimal + /////////////////////////////////////////////////////////////////////// + void SetLeaderActivityIdString(FIT_UINT8 index, FIT_WSTRING leaderActivityIdString) + { + SetFieldSTRINGValue(10, leaderActivityIdString, index); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of default_race_leader field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDefaultRaceLeaderValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns default_race_leader field + // Comment: Index for the Leader Board entry selected as the default race participant + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDefaultRaceLeader(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set default_race_leader field + // Comment: Index for the Leader Board entry selected as the default race participant + /////////////////////////////////////////////////////////////////////// + void SetDefaultRaceLeader(FIT_UINT8 defaultRaceLeader) + { + SetFieldUINT8Value(11, defaultRaceLeader, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_FILE_MESG_HPP) diff --git a/fit_segment_file_mesg_listener.hpp b/fit_segment_file_mesg_listener.hpp new file mode 100644 index 0000000..270c279 --- /dev/null +++ b/fit_segment_file_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_FILE_MESG_LISTENER_HPP) +#define FIT_SEGMENT_FILE_MESG_LISTENER_HPP + +#include "fit_segment_file_mesg.hpp" + +namespace fit +{ + +class SegmentFileMesgListener +{ +public: + virtual ~SegmentFileMesgListener() {} + virtual void OnMesg(SegmentFileMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_FILE_MESG_LISTENER_HPP) diff --git a/fit_segment_id_mesg.hpp b/fit_segment_id_mesg.hpp new file mode 100644 index 0000000..f8d92f7 --- /dev/null +++ b/fit_segment_id_mesg.hpp @@ -0,0 +1,348 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_ID_MESG_HPP) +#define FIT_SEGMENT_ID_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SegmentIdMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Name = 0; + static const FIT_UINT8 Uuid = 1; + static const FIT_UINT8 Sport = 2; + static const FIT_UINT8 Enabled = 3; + static const FIT_UINT8 UserProfilePrimaryKey = 4; + static const FIT_UINT8 DeviceId = 5; + static const FIT_UINT8 DefaultRaceLeader = 6; + static const FIT_UINT8 DeleteStatus = 7; + static const FIT_UINT8 SelectionType = 8; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SegmentIdMesg(void) : Mesg(Profile::MESG_SEGMENT_ID) + { + } + + SegmentIdMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + // Comment: Friendly name assigned to segment + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + // Comment: Friendly name assigned to segment + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(0, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of uuid field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUuidValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns uuid field + // Comment: UUID of the segment + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetUuid(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set uuid field + // Comment: UUID of the segment + /////////////////////////////////////////////////////////////////////// + void SetUuid(FIT_WSTRING uuid) + { + SetFieldSTRINGValue(1, uuid, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + // Comment: Sport associated with the segment + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + // Comment: Sport associated with the segment + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(2, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enabled field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnabledValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enabled field + // Comment: Segment enabled for evaluation + /////////////////////////////////////////////////////////////////////// + FIT_BOOL GetEnabled(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enabled field + // Comment: Segment enabled for evaluation + /////////////////////////////////////////////////////////////////////// + void SetEnabled(FIT_BOOL enabled) + { + SetFieldENUMValue(3, enabled, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of user_profile_primary_key field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUserProfilePrimaryKeyValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns user_profile_primary_key field + // Comment: Primary key of the user that created the segment + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetUserProfilePrimaryKey(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set user_profile_primary_key field + // Comment: Primary key of the user that created the segment + /////////////////////////////////////////////////////////////////////// + void SetUserProfilePrimaryKey(FIT_UINT32 userProfilePrimaryKey) + { + SetFieldUINT32Value(4, userProfilePrimaryKey, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of device_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeviceIdValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns device_id field + // Comment: ID of the device that created the segment + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDeviceId(void) const + { + return GetFieldUINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set device_id field + // Comment: ID of the device that created the segment + /////////////////////////////////////////////////////////////////////// + void SetDeviceId(FIT_UINT32 deviceId) + { + SetFieldUINT32Value(5, deviceId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of default_race_leader field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDefaultRaceLeaderValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns default_race_leader field + // Comment: Index for the Leader Board entry selected as the default race participant + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDefaultRaceLeader(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set default_race_leader field + // Comment: Index for the Leader Board entry selected as the default race participant + /////////////////////////////////////////////////////////////////////// + void SetDefaultRaceLeader(FIT_UINT8 defaultRaceLeader) + { + SetFieldUINT8Value(6, defaultRaceLeader, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of delete_status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeleteStatusValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns delete_status field + // Comment: Indicates if any segments should be deleted + /////////////////////////////////////////////////////////////////////// + FIT_SEGMENT_DELETE_STATUS GetDeleteStatus(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set delete_status field + // Comment: Indicates if any segments should be deleted + /////////////////////////////////////////////////////////////////////// + void SetDeleteStatus(FIT_SEGMENT_DELETE_STATUS deleteStatus) + { + SetFieldENUMValue(7, deleteStatus, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of selection_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSelectionTypeValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns selection_type field + // Comment: Indicates how the segment was selected to be sent to the device + /////////////////////////////////////////////////////////////////////// + FIT_SEGMENT_SELECTION_TYPE GetSelectionType(void) const + { + return GetFieldENUMValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set selection_type field + // Comment: Indicates how the segment was selected to be sent to the device + /////////////////////////////////////////////////////////////////////// + void SetSelectionType(FIT_SEGMENT_SELECTION_TYPE selectionType) + { + SetFieldENUMValue(8, selectionType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_ID_MESG_HPP) diff --git a/fit_segment_id_mesg_listener.hpp b/fit_segment_id_mesg_listener.hpp new file mode 100644 index 0000000..caa03bf --- /dev/null +++ b/fit_segment_id_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_ID_MESG_LISTENER_HPP) +#define FIT_SEGMENT_ID_MESG_LISTENER_HPP + +#include "fit_segment_id_mesg.hpp" + +namespace fit +{ + +class SegmentIdMesgListener +{ +public: + virtual ~SegmentIdMesgListener() {} + virtual void OnMesg(SegmentIdMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_ID_MESG_LISTENER_HPP) diff --git a/fit_segment_lap_mesg.hpp b/fit_segment_lap_mesg.hpp new file mode 100644 index 0000000..ef8e958 --- /dev/null +++ b/fit_segment_lap_mesg.hpp @@ -0,0 +1,3434 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_LAP_MESG_HPP) +#define FIT_SEGMENT_LAP_MESG_HPP + +#include "fit_mesg.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class SegmentLapMesg : public Mesg, public MesgWithEvent +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Event = 0; + static const FIT_UINT8 EventType = 1; + static const FIT_UINT8 StartTime = 2; + static const FIT_UINT8 StartPositionLat = 3; + static const FIT_UINT8 StartPositionLong = 4; + static const FIT_UINT8 EndPositionLat = 5; + static const FIT_UINT8 EndPositionLong = 6; + static const FIT_UINT8 TotalElapsedTime = 7; + static const FIT_UINT8 TotalTimerTime = 8; + static const FIT_UINT8 TotalDistance = 9; + static const FIT_UINT8 TotalCycles = 10; + static const FIT_UINT8 TotalCalories = 11; + static const FIT_UINT8 TotalFatCalories = 12; + static const FIT_UINT8 AvgSpeed = 13; + static const FIT_UINT8 MaxSpeed = 14; + static const FIT_UINT8 AvgHeartRate = 15; + static const FIT_UINT8 MaxHeartRate = 16; + static const FIT_UINT8 AvgCadence = 17; + static const FIT_UINT8 MaxCadence = 18; + static const FIT_UINT8 AvgPower = 19; + static const FIT_UINT8 MaxPower = 20; + static const FIT_UINT8 TotalAscent = 21; + static const FIT_UINT8 TotalDescent = 22; + static const FIT_UINT8 Sport = 23; + static const FIT_UINT8 EventGroup = 24; + static const FIT_UINT8 NecLat = 25; + static const FIT_UINT8 NecLong = 26; + static const FIT_UINT8 SwcLat = 27; + static const FIT_UINT8 SwcLong = 28; + static const FIT_UINT8 Name = 29; + static const FIT_UINT8 NormalizedPower = 30; + static const FIT_UINT8 LeftRightBalance = 31; + static const FIT_UINT8 SubSport = 32; + static const FIT_UINT8 TotalWork = 33; + static const FIT_UINT8 AvgAltitude = 34; + static const FIT_UINT8 MaxAltitude = 35; + static const FIT_UINT8 GpsAccuracy = 36; + static const FIT_UINT8 AvgGrade = 37; + static const FIT_UINT8 AvgPosGrade = 38; + static const FIT_UINT8 AvgNegGrade = 39; + static const FIT_UINT8 MaxPosGrade = 40; + static const FIT_UINT8 MaxNegGrade = 41; + static const FIT_UINT8 AvgTemperature = 42; + static const FIT_UINT8 MaxTemperature = 43; + static const FIT_UINT8 TotalMovingTime = 44; + static const FIT_UINT8 AvgPosVerticalSpeed = 45; + static const FIT_UINT8 AvgNegVerticalSpeed = 46; + static const FIT_UINT8 MaxPosVerticalSpeed = 47; + static const FIT_UINT8 MaxNegVerticalSpeed = 48; + static const FIT_UINT8 TimeInHrZone = 49; + static const FIT_UINT8 TimeInSpeedZone = 50; + static const FIT_UINT8 TimeInCadenceZone = 51; + static const FIT_UINT8 TimeInPowerZone = 52; + static const FIT_UINT8 RepetitionNum = 53; + static const FIT_UINT8 MinAltitude = 54; + static const FIT_UINT8 MinHeartRate = 55; + static const FIT_UINT8 ActiveTime = 56; + static const FIT_UINT8 WktStepIndex = 57; + static const FIT_UINT8 SportEvent = 58; + static const FIT_UINT8 AvgLeftTorqueEffectiveness = 59; + static const FIT_UINT8 AvgRightTorqueEffectiveness = 60; + static const FIT_UINT8 AvgLeftPedalSmoothness = 61; + static const FIT_UINT8 AvgRightPedalSmoothness = 62; + static const FIT_UINT8 AvgCombinedPedalSmoothness = 63; + static const FIT_UINT8 Status = 64; + static const FIT_UINT8 Uuid = 65; + static const FIT_UINT8 AvgFractionalCadence = 66; + static const FIT_UINT8 MaxFractionalCadence = 67; + static const FIT_UINT8 TotalFractionalCycles = 68; + static const FIT_UINT8 FrontGearShiftCount = 69; + static const FIT_UINT8 RearGearShiftCount = 70; + static const FIT_UINT8 TimeStanding = 71; + static const FIT_UINT8 StandCount = 72; + static const FIT_UINT8 AvgLeftPco = 73; + static const FIT_UINT8 AvgRightPco = 74; + static const FIT_UINT8 AvgLeftPowerPhase = 75; + static const FIT_UINT8 AvgLeftPowerPhasePeak = 76; + static const FIT_UINT8 AvgRightPowerPhase = 77; + static const FIT_UINT8 AvgRightPowerPhasePeak = 78; + static const FIT_UINT8 AvgPowerPosition = 79; + static const FIT_UINT8 MaxPowerPosition = 80; + static const FIT_UINT8 AvgCadencePosition = 81; + static const FIT_UINT8 MaxCadencePosition = 82; + static const FIT_UINT8 Manufacturer = 83; + static const FIT_UINT8 TotalGrit = 84; + static const FIT_UINT8 TotalFlow = 85; + static const FIT_UINT8 AvgGrit = 86; + static const FIT_UINT8 AvgFlow = 87; + static const FIT_UINT8 TotalFractionalAscent = 89; + static const FIT_UINT8 TotalFractionalDescent = 90; + static const FIT_UINT8 EnhancedAvgAltitude = 91; + static const FIT_UINT8 EnhancedMaxAltitude = 92; + static const FIT_UINT8 EnhancedMinAltitude = 93; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SegmentLapMesg(void) : Mesg(Profile::MESG_SEGMENT_LAP) + { + } + + SegmentLapMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT GetEvent(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event field + /////////////////////////////////////////////////////////////////////// + void SetEvent(FIT_EVENT event) + { + SetFieldENUMValue(0, event, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_type field + /////////////////////////////////////////////////////////////////////// + FIT_EVENT_TYPE GetEventType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_type field + /////////////////////////////////////////////////////////////////////// + void SetEventType(FIT_EVENT_TYPE eventType) + { + SetFieldENUMValue(1, eventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTime(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_time field + /////////////////////////////////////////////////////////////////////// + void SetStartTime(FIT_DATE_TIME startTime) + { + SetFieldUINT32Value(2, startTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLatValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLat(void) const + { + return GetFieldSINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLat(FIT_SINT32 startPositionLat) + { + SetFieldSINT32Value(3, startPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLongValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLong(void) const + { + return GetFieldSINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLong(FIT_SINT32 startPositionLong) + { + SetFieldSINT32Value(4, startPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLatValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLat(void) const + { + return GetFieldSINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLat(FIT_SINT32 endPositionLat) + { + SetFieldSINT32Value(5, endPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLongValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLong(void) const + { + return GetFieldSINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLong(FIT_SINT32 endPositionLong) + { + SetFieldSINT32Value(6, endPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_elapsed_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalElapsedTimeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_elapsed_time field + // Units: s + // Comment: Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalElapsedTime(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_elapsed_time field + // Units: s + // Comment: Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + void SetTotalElapsedTime(FIT_FLOAT32 totalElapsedTime) + { + SetFieldFLOAT32Value(7, totalElapsedTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + // Comment: Timer Time (excludes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + // Comment: Timer Time (excludes pauses) + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(8, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDistanceValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalDistance(void) const + { + return GetFieldFLOAT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDistance(FIT_FLOAT32 totalDistance) + { + SetFieldFLOAT32Value(9, totalDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCyclesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalCycles(void) const + { + return GetFieldUINT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalCycles(FIT_UINT32 totalCycles) + { + SetFieldUINT32Value(10, totalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_strokes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalStrokesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalStrokes(void) const + { + return GetFieldUINT32Value(10, 0, (FIT_UINT16) Profile::SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + void SetTotalStrokes(FIT_UINT32 totalStrokes) + { + SetFieldUINT32Value(10, totalStrokes, 0, (FIT_UINT16) Profile::SEGMENT_LAP_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCaloriesValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalCalories(void) const + { + return GetFieldUINT16Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalCalories(FIT_UINT16 totalCalories) + { + SetFieldUINT16Value(11, totalCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fat_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFatCaloriesValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fat_calories field + // Units: kcal + // Comment: If New Leaf + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalFatCalories(void) const + { + return GetFieldUINT16Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fat_calories field + // Units: kcal + // Comment: If New Leaf + /////////////////////////////////////////////////////////////////////// + void SetTotalFatCalories(FIT_UINT16 totalFatCalories) + { + SetFieldUINT16Value(12, totalFatCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(13, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSpeedValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSpeed(void) const + { + return GetFieldFLOAT32Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxSpeed(FIT_FLOAT32 maxSpeed) + { + SetFieldFLOAT32Value(14, maxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgHeartRateValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgHeartRate(void) const + { + return GetFieldUINT8Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetAvgHeartRate(FIT_UINT8 avgHeartRate) + { + SetFieldUINT8Value(15, avgHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxHeartRateValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxHeartRate(void) const + { + return GetFieldUINT8Value(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMaxHeartRate(FIT_UINT8 maxHeartRate) + { + SetFieldUINT8Value(16, maxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCadenceValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_cadence field + // Units: rpm + // Comment: total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgCadence(void) const + { + return GetFieldUINT8Value(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_cadence field + // Units: rpm + // Comment: total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + void SetAvgCadence(FIT_UINT8 avgCadence) + { + SetFieldUINT8Value(17, avgCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCadenceValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxCadence(void) const + { + return GetFieldUINT8Value(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetMaxCadence(FIT_UINT8 maxCadence) + { + SetFieldUINT8Value(18, maxCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPowerValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_power field + // Units: watts + // Comment: total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgPower(void) const + { + return GetFieldUINT16Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_power field + // Units: watts + // Comment: total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + void SetAvgPower(FIT_UINT16 avgPower) + { + SetFieldUINT16Value(19, avgPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPowerValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPower(void) const + { + return GetFieldUINT16Value(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetMaxPower(FIT_UINT16 maxPower) + { + SetFieldUINT16Value(20, maxPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalAscentValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalAscent(void) const + { + return GetFieldUINT16Value(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalAscent(FIT_UINT16 totalAscent) + { + SetFieldUINT16Value(21, totalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDescentValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalDescent(void) const + { + return GetFieldUINT16Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDescent(FIT_UINT16 totalDescent) + { + SetFieldUINT16Value(22, totalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(23, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_group field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventGroupValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_group field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventGroup(void) const + { + return GetFieldUINT8Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_group field + /////////////////////////////////////////////////////////////////////// + void SetEventGroup(FIT_UINT8 eventGroup) + { + SetFieldUINT8Value(24, eventGroup, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of nec_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNecLatValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns nec_lat field + // Units: semicircles + // Comment: North east corner latitude. + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetNecLat(void) const + { + return GetFieldSINT32Value(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set nec_lat field + // Units: semicircles + // Comment: North east corner latitude. + /////////////////////////////////////////////////////////////////////// + void SetNecLat(FIT_SINT32 necLat) + { + SetFieldSINT32Value(25, necLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of nec_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNecLongValid() const + { + const Field* field = GetField(26); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns nec_long field + // Units: semicircles + // Comment: North east corner longitude. + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetNecLong(void) const + { + return GetFieldSINT32Value(26, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set nec_long field + // Units: semicircles + // Comment: North east corner longitude. + /////////////////////////////////////////////////////////////////////// + void SetNecLong(FIT_SINT32 necLong) + { + SetFieldSINT32Value(26, necLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swc_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwcLatValid() const + { + const Field* field = GetField(27); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swc_lat field + // Units: semicircles + // Comment: South west corner latitude. + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetSwcLat(void) const + { + return GetFieldSINT32Value(27, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swc_lat field + // Units: semicircles + // Comment: South west corner latitude. + /////////////////////////////////////////////////////////////////////// + void SetSwcLat(FIT_SINT32 swcLat) + { + SetFieldSINT32Value(27, swcLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swc_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwcLongValid() const + { + const Field* field = GetField(28); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swc_long field + // Units: semicircles + // Comment: South west corner latitude. + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetSwcLong(void) const + { + return GetFieldSINT32Value(28, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swc_long field + // Units: semicircles + // Comment: South west corner latitude. + /////////////////////////////////////////////////////////////////////// + void SetSwcLong(FIT_SINT32 swcLong) + { + SetFieldSINT32Value(28, swcLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(29); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(29, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(29, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of normalized_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNormalizedPowerValid() const + { + const Field* field = GetField(30); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns normalized_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNormalizedPower(void) const + { + return GetFieldUINT16Value(30, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set normalized_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetNormalizedPower(FIT_UINT16 normalizedPower) + { + SetFieldUINT16Value(30, normalizedPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_right_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftRightBalanceValid() const + { + const Field* field = GetField(31); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_right_balance field + /////////////////////////////////////////////////////////////////////// + FIT_LEFT_RIGHT_BALANCE_100 GetLeftRightBalance(void) const + { + return GetFieldUINT16Value(31, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_right_balance field + /////////////////////////////////////////////////////////////////////// + void SetLeftRightBalance(FIT_LEFT_RIGHT_BALANCE_100 leftRightBalance) + { + SetFieldUINT16Value(31, leftRightBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(32, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_work field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalWorkValid() const + { + const Field* field = GetField(33); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_work field + // Units: J + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalWork(void) const + { + return GetFieldUINT32Value(33, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_work field + // Units: J + /////////////////////////////////////////////////////////////////////// + void SetTotalWork(FIT_UINT32 totalWork) + { + SetFieldUINT32Value(33, totalWork, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgAltitudeValid() const + { + const Field* field = GetField(34); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgAltitude(void) const + { + return GetFieldFLOAT32Value(34, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAvgAltitude(FIT_FLOAT32 avgAltitude) + { + SetFieldFLOAT32Value(34, avgAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxAltitudeValid() const + { + const Field* field = GetField(35); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxAltitude(void) const + { + return GetFieldFLOAT32Value(35, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetMaxAltitude(FIT_FLOAT32 maxAltitude) + { + SetFieldFLOAT32Value(35, maxAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gps_accuracy field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGpsAccuracyValid() const + { + const Field* field = GetField(36); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGpsAccuracy(void) const + { + return GetFieldUINT8Value(36, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetGpsAccuracy(FIT_UINT8 gpsAccuracy) + { + SetFieldUINT8Value(36, gpsAccuracy, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgGradeValid() const + { + const Field* field = GetField(37); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgGrade(void) const + { + return GetFieldFLOAT32Value(37, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgGrade(FIT_FLOAT32 avgGrade) + { + SetFieldFLOAT32Value(37, avgGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pos_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPosGradeValid() const + { + const Field* field = GetField(38); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPosGrade(void) const + { + return GetFieldFLOAT32Value(38, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgPosGrade(FIT_FLOAT32 avgPosGrade) + { + SetFieldFLOAT32Value(38, avgPosGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_neg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgNegGradeValid() const + { + const Field* field = GetField(39); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgNegGrade(void) const + { + return GetFieldFLOAT32Value(39, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgNegGrade(FIT_FLOAT32 avgNegGrade) + { + SetFieldFLOAT32Value(39, avgNegGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_pos_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPosGradeValid() const + { + const Field* field = GetField(40); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxPosGrade(void) const + { + return GetFieldFLOAT32Value(40, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetMaxPosGrade(FIT_FLOAT32 maxPosGrade) + { + SetFieldFLOAT32Value(40, maxPosGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_neg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxNegGradeValid() const + { + const Field* field = GetField(41); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxNegGrade(void) const + { + return GetFieldFLOAT32Value(41, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetMaxNegGrade(FIT_FLOAT32 maxNegGrade) + { + SetFieldFLOAT32Value(41, maxNegGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgTemperatureValid() const + { + const Field* field = GetField(42); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgTemperature(void) const + { + return GetFieldSINT8Value(42, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetAvgTemperature(FIT_SINT8 avgTemperature) + { + SetFieldSINT8Value(42, avgTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxTemperatureValid() const + { + const Field* field = GetField(43); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetMaxTemperature(void) const + { + return GetFieldSINT8Value(43, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMaxTemperature(FIT_SINT8 maxTemperature) + { + SetFieldSINT8Value(43, maxTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_moving_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalMovingTimeValid() const + { + const Field* field = GetField(44); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalMovingTime(void) const + { + return GetFieldFLOAT32Value(44, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalMovingTime(FIT_FLOAT32 totalMovingTime) + { + SetFieldFLOAT32Value(44, totalMovingTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pos_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPosVerticalSpeedValid() const + { + const Field* field = GetField(45); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPosVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(45, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgPosVerticalSpeed(FIT_FLOAT32 avgPosVerticalSpeed) + { + SetFieldFLOAT32Value(45, avgPosVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_neg_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgNegVerticalSpeedValid() const + { + const Field* field = GetField(46); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgNegVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(46, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgNegVerticalSpeed(FIT_FLOAT32 avgNegVerticalSpeed) + { + SetFieldFLOAT32Value(46, avgNegVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_pos_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPosVerticalSpeedValid() const + { + const Field* field = GetField(47); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxPosVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(47, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxPosVerticalSpeed(FIT_FLOAT32 maxPosVerticalSpeed) + { + SetFieldFLOAT32Value(47, maxPosVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_neg_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxNegVerticalSpeedValid() const + { + const Field* field = GetField(48); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxNegVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(48, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxNegVerticalSpeed(FIT_FLOAT32 maxNegVerticalSpeed) + { + SetFieldFLOAT32Value(48, maxNegVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_hr_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInHrZone(void) const + { + return GetFieldNumValues(49, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_hr_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInHrZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(49); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInHrZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(49, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInHrZone(FIT_UINT8 index, FIT_FLOAT32 timeInHrZone) + { + SetFieldFLOAT32Value(49, timeInHrZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_speed_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInSpeedZone(void) const + { + return GetFieldNumValues(50, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_speed_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInSpeedZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(50); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInSpeedZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(50, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInSpeedZone(FIT_UINT8 index, FIT_FLOAT32 timeInSpeedZone) + { + SetFieldFLOAT32Value(50, timeInSpeedZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_cadence_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInCadenceZone(void) const + { + return GetFieldNumValues(51, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_cadence_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInCadenceZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(51); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInCadenceZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(51, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInCadenceZone(FIT_UINT8 index, FIT_FLOAT32 timeInCadenceZone) + { + SetFieldFLOAT32Value(51, timeInCadenceZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_power_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInPowerZone(void) const + { + return GetFieldNumValues(52, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_power_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInPowerZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(52); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInPowerZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(52, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInPowerZone(FIT_UINT8 index, FIT_FLOAT32 timeInPowerZone) + { + SetFieldFLOAT32Value(52, timeInPowerZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repetition_num field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepetitionNumValid() const + { + const Field* field = GetField(53); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repetition_num field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRepetitionNum(void) const + { + return GetFieldUINT16Value(53, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repetition_num field + /////////////////////////////////////////////////////////////////////// + void SetRepetitionNum(FIT_UINT16 repetitionNum) + { + SetFieldUINT16Value(53, repetitionNum, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinAltitudeValid() const + { + const Field* field = GetField(54); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinAltitude(void) const + { + return GetFieldFLOAT32Value(54, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetMinAltitude(FIT_FLOAT32 minAltitude) + { + SetFieldFLOAT32Value(54, minAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinHeartRateValid() const + { + const Field* field = GetField(55); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMinHeartRate(void) const + { + return GetFieldUINT8Value(55, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMinHeartRate(FIT_UINT8 minHeartRate) + { + SetFieldUINT8Value(55, minHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveTimeValid() const + { + const Field* field = GetField(56); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetActiveTime(void) const + { + return GetFieldFLOAT32Value(56, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetActiveTime(FIT_FLOAT32 activeTime) + { + SetFieldFLOAT32Value(56, activeTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_step_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktStepIndexValid() const + { + const Field* field = GetField(57); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_step_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetWktStepIndex(void) const + { + return GetFieldUINT16Value(57, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_step_index field + /////////////////////////////////////////////////////////////////////// + void SetWktStepIndex(FIT_MESSAGE_INDEX wktStepIndex) + { + SetFieldUINT16Value(57, wktStepIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport_event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportEventValid() const + { + const Field* field = GetField(58); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport_event field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT_EVENT GetSportEvent(void) const + { + return GetFieldENUMValue(58, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport_event field + /////////////////////////////////////////////////////////////////////// + void SetSportEvent(FIT_SPORT_EVENT sportEvent) + { + SetFieldENUMValue(58, sportEvent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftTorqueEffectivenessValid() const + { + const Field* field = GetField(59); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(59, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftTorqueEffectiveness(FIT_FLOAT32 avgLeftTorqueEffectiveness) + { + SetFieldFLOAT32Value(59, avgLeftTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightTorqueEffectivenessValid() const + { + const Field* field = GetField(60); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(60, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgRightTorqueEffectiveness(FIT_FLOAT32 avgRightTorqueEffectiveness) + { + SetFieldFLOAT32Value(60, avgRightTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPedalSmoothnessValid() const + { + const Field* field = GetField(61); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(61, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPedalSmoothness(FIT_FLOAT32 avgLeftPedalSmoothness) + { + SetFieldFLOAT32Value(61, avgLeftPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPedalSmoothnessValid() const + { + const Field* field = GetField(62); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(62, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPedalSmoothness(FIT_FLOAT32 avgRightPedalSmoothness) + { + SetFieldFLOAT32Value(62, avgRightPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_combined_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCombinedPedalSmoothnessValid() const + { + const Field* field = GetField(63); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgCombinedPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(63, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgCombinedPedalSmoothness(FIT_FLOAT32 avgCombinedPedalSmoothness) + { + SetFieldFLOAT32Value(63, avgCombinedPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of status field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStatusValid() const + { + const Field* field = GetField(64); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns status field + /////////////////////////////////////////////////////////////////////// + FIT_SEGMENT_LAP_STATUS GetStatus(void) const + { + return GetFieldENUMValue(64, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set status field + /////////////////////////////////////////////////////////////////////// + void SetStatus(FIT_SEGMENT_LAP_STATUS status) + { + SetFieldENUMValue(64, status, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of uuid field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUuidValid() const + { + const Field* field = GetField(65); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns uuid field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetUuid(void) const + { + return GetFieldSTRINGValue(65, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set uuid field + /////////////////////////////////////////////////////////////////////// + void SetUuid(FIT_WSTRING uuid) + { + SetFieldSTRINGValue(65, uuid, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgFractionalCadenceValid() const + { + const Field* field = GetField(66); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_fractional_cadence field + // Units: rpm + // Comment: fractional part of the avg_cadence + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgFractionalCadence(void) const + { + return GetFieldFLOAT32Value(66, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_fractional_cadence field + // Units: rpm + // Comment: fractional part of the avg_cadence + /////////////////////////////////////////////////////////////////////// + void SetAvgFractionalCadence(FIT_FLOAT32 avgFractionalCadence) + { + SetFieldFLOAT32Value(66, avgFractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxFractionalCadenceValid() const + { + const Field* field = GetField(67); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_fractional_cadence field + // Units: rpm + // Comment: fractional part of the max_cadence + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxFractionalCadence(void) const + { + return GetFieldFLOAT32Value(67, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_fractional_cadence field + // Units: rpm + // Comment: fractional part of the max_cadence + /////////////////////////////////////////////////////////////////////// + void SetMaxFractionalCadence(FIT_FLOAT32 maxFractionalCadence) + { + SetFieldFLOAT32Value(67, maxFractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalCyclesValid() const + { + const Field* field = GetField(68); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_cycles field + // Units: cycles + // Comment: fractional part of the total_cycles + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalCycles(void) const + { + return GetFieldFLOAT32Value(68, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_cycles field + // Units: cycles + // Comment: fractional part of the total_cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalCycles(FIT_FLOAT32 totalFractionalCycles) + { + SetFieldFLOAT32Value(68, totalFractionalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of front_gear_shift_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFrontGearShiftCountValid() const + { + const Field* field = GetField(69); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns front_gear_shift_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetFrontGearShiftCount(void) const + { + return GetFieldUINT16Value(69, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set front_gear_shift_count field + /////////////////////////////////////////////////////////////////////// + void SetFrontGearShiftCount(FIT_UINT16 frontGearShiftCount) + { + SetFieldUINT16Value(69, frontGearShiftCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rear_gear_shift_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRearGearShiftCountValid() const + { + const Field* field = GetField(70); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rear_gear_shift_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRearGearShiftCount(void) const + { + return GetFieldUINT16Value(70, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rear_gear_shift_count field + /////////////////////////////////////////////////////////////////////// + void SetRearGearShiftCount(FIT_UINT16 rearGearShiftCount) + { + SetFieldUINT16Value(70, rearGearShiftCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_standing field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeStandingValid() const + { + const Field* field = GetField(71); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_standing field + // Units: s + // Comment: Total time spent in the standing position + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeStanding(void) const + { + return GetFieldFLOAT32Value(71, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_standing field + // Units: s + // Comment: Total time spent in the standing position + /////////////////////////////////////////////////////////////////////// + void SetTimeStanding(FIT_FLOAT32 timeStanding) + { + SetFieldFLOAT32Value(71, timeStanding, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stand_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStandCountValid() const + { + const Field* field = GetField(72); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stand_count field + // Comment: Number of transitions to the standing state + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStandCount(void) const + { + return GetFieldUINT16Value(72, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stand_count field + // Comment: Number of transitions to the standing state + /////////////////////////////////////////////////////////////////////// + void SetStandCount(FIT_UINT16 standCount) + { + SetFieldUINT16Value(72, standCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPcoValid() const + { + const Field* field = GetField(73); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_pco field + // Units: mm + // Comment: Average left platform center offset + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgLeftPco(void) const + { + return GetFieldSINT8Value(73, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_pco field + // Units: mm + // Comment: Average left platform center offset + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPco(FIT_SINT8 avgLeftPco) + { + SetFieldSINT8Value(73, avgLeftPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPcoValid() const + { + const Field* field = GetField(74); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_pco field + // Units: mm + // Comment: Average right platform center offset + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgRightPco(void) const + { + return GetFieldSINT8Value(74, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_pco field + // Units: mm + // Comment: Average right platform center offset + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPco(FIT_SINT8 avgRightPco) + { + SetFieldSINT8Value(74, avgRightPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_left_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgLeftPowerPhase(void) const + { + return GetFieldNumValues(75, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(75); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_power_phase field + // Units: degrees + // Comment: Average left power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(75, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_power_phase field + // Units: degrees + // Comment: Average left power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPowerPhase(FIT_UINT8 index, FIT_FLOAT32 avgLeftPowerPhase) + { + SetFieldFLOAT32Value(75, avgLeftPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_left_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgLeftPowerPhasePeak(void) const + { + return GetFieldNumValues(76, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(76); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_power_phase_peak field + // Units: degrees + // Comment: Average left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(76, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_power_phase_peak field + // Units: degrees + // Comment: Average left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 avgLeftPowerPhasePeak) + { + SetFieldFLOAT32Value(76, avgLeftPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_right_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgRightPowerPhase(void) const + { + return GetFieldNumValues(77, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(77); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_power_phase field + // Units: degrees + // Comment: Average right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(77, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_power_phase field + // Units: degrees + // Comment: Average right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPowerPhase(FIT_UINT8 index, FIT_FLOAT32 avgRightPowerPhase) + { + SetFieldFLOAT32Value(77, avgRightPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_right_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgRightPowerPhasePeak(void) const + { + return GetFieldNumValues(78, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(78); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_power_phase_peak field + // Units: degrees + // Comment: Average right power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(78, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_power_phase_peak field + // Units: degrees + // Comment: Average right power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 avgRightPowerPhasePeak) + { + SetFieldFLOAT32Value(78, avgRightPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_power_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgPowerPosition(void) const + { + return GetFieldNumValues(79, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_power_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPowerPositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(79); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_power_position field + // Units: watts + // Comment: Average power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgPowerPosition(FIT_UINT8 index) const + { + return GetFieldUINT16Value(79, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_power_position field + // Units: watts + // Comment: Average power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgPowerPosition(FIT_UINT8 index, FIT_UINT16 avgPowerPosition) + { + SetFieldUINT16Value(79, avgPowerPosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_power_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxPowerPosition(void) const + { + return GetFieldNumValues(80, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_power_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPowerPositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(80); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_power_position field + // Units: watts + // Comment: Maximum power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPowerPosition(FIT_UINT8 index) const + { + return GetFieldUINT16Value(80, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_power_position field + // Units: watts + // Comment: Maximum power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetMaxPowerPosition(FIT_UINT8 index, FIT_UINT16 maxPowerPosition) + { + SetFieldUINT16Value(80, maxPowerPosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_cadence_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgCadencePosition(void) const + { + return GetFieldNumValues(81, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_cadence_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCadencePositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(81); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_cadence_position field + // Units: rpm + // Comment: Average cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgCadencePosition(FIT_UINT8 index) const + { + return GetFieldUINT8Value(81, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_cadence_position field + // Units: rpm + // Comment: Average cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgCadencePosition(FIT_UINT8 index, FIT_UINT8 avgCadencePosition) + { + SetFieldUINT8Value(81, avgCadencePosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_cadence_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxCadencePosition(void) const + { + return GetFieldNumValues(82, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_cadence_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCadencePositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(82); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_cadence_position field + // Units: rpm + // Comment: Maximum cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxCadencePosition(FIT_UINT8 index) const + { + return GetFieldUINT8Value(82, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_cadence_position field + // Units: rpm + // Comment: Maximum cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetMaxCadencePosition(FIT_UINT8 index, FIT_UINT8 maxCadencePosition) + { + SetFieldUINT8Value(82, maxCadencePosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerValid() const + { + const Field* field = GetField(83); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer field + // Comment: Manufacturer that produced the segment + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturer(void) const + { + return GetFieldUINT16Value(83, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer field + // Comment: Manufacturer that produced the segment + /////////////////////////////////////////////////////////////////////// + void SetManufacturer(FIT_MANUFACTURER manufacturer) + { + SetFieldUINT16Value(83, manufacturer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalGritValid() const + { + const Field* field = GetField(84); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalGrit(void) const + { + return GetFieldFLOAT32Value(84, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetTotalGrit(FIT_FLOAT32 totalGrit) + { + SetFieldFLOAT32Value(84, totalGrit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFlowValid() const + { + const Field* field = GetField(85); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFlow(void) const + { + return GetFieldFLOAT32Value(85, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetTotalFlow(FIT_FLOAT32 totalFlow) + { + SetFieldFLOAT32Value(85, totalFlow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgGritValid() const + { + const Field* field = GetField(86); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgGrit(void) const + { + return GetFieldFLOAT32Value(86, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetAvgGrit(FIT_FLOAT32 avgGrit) + { + SetFieldFLOAT32Value(86, avgGrit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgFlowValid() const + { + const Field* field = GetField(87); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgFlow(void) const + { + return GetFieldFLOAT32Value(87, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetAvgFlow(FIT_FLOAT32 avgFlow) + { + SetFieldFLOAT32Value(87, avgFlow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalAscentValid() const + { + const Field* field = GetField(89); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_ascent field + // Units: m + // Comment: fractional part of total_ascent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalAscent(void) const + { + return GetFieldFLOAT32Value(89, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_ascent field + // Units: m + // Comment: fractional part of total_ascent + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalAscent(FIT_FLOAT32 totalFractionalAscent) + { + SetFieldFLOAT32Value(89, totalFractionalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalDescentValid() const + { + const Field* field = GetField(90); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_descent field + // Units: m + // Comment: fractional part of total_descent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalDescent(void) const + { + return GetFieldFLOAT32Value(90, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_descent field + // Units: m + // Comment: fractional part of total_descent + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalDescent(FIT_FLOAT32 totalFractionalDescent) + { + SetFieldFLOAT32Value(90, totalFractionalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgAltitudeValid() const + { + const Field* field = GetField(91); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgAltitude(void) const + { + return GetFieldFLOAT32Value(91, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgAltitude(FIT_FLOAT32 enhancedAvgAltitude) + { + SetFieldFLOAT32Value(91, enhancedAvgAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxAltitudeValid() const + { + const Field* field = GetField(92); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxAltitude(void) const + { + return GetFieldFLOAT32Value(92, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxAltitude(FIT_FLOAT32 enhancedMaxAltitude) + { + SetFieldFLOAT32Value(92, enhancedMaxAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_min_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMinAltitudeValid() const + { + const Field* field = GetField(93); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMinAltitude(void) const + { + return GetFieldFLOAT32Value(93, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMinAltitude(FIT_FLOAT32 enhancedMinAltitude) + { + SetFieldFLOAT32Value(93, enhancedMinAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_LAP_MESG_HPP) diff --git a/fit_segment_lap_mesg_listener.hpp b/fit_segment_lap_mesg_listener.hpp new file mode 100644 index 0000000..c20f3d0 --- /dev/null +++ b/fit_segment_lap_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_LAP_MESG_LISTENER_HPP) +#define FIT_SEGMENT_LAP_MESG_LISTENER_HPP + +#include "fit_segment_lap_mesg.hpp" + +namespace fit +{ + +class SegmentLapMesgListener +{ +public: + virtual ~SegmentLapMesgListener() {} + virtual void OnMesg(SegmentLapMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_LAP_MESG_LISTENER_HPP) diff --git a/fit_segment_leaderboard_entry_mesg.hpp b/fit_segment_leaderboard_entry_mesg.hpp new file mode 100644 index 0000000..54996e2 --- /dev/null +++ b/fit_segment_leaderboard_entry_mesg.hpp @@ -0,0 +1,280 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_LEADERBOARD_ENTRY_MESG_HPP) +#define FIT_SEGMENT_LEADERBOARD_ENTRY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SegmentLeaderboardEntryMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Name = 0; + static const FIT_UINT8 Type = 1; + static const FIT_UINT8 GroupPrimaryKey = 2; + static const FIT_UINT8 ActivityId = 3; + static const FIT_UINT8 SegmentTime = 4; + static const FIT_UINT8 ActivityIdString = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SegmentLeaderboardEntryMesg(void) : Mesg(Profile::MESG_SEGMENT_LEADERBOARD_ENTRY) + { + } + + SegmentLeaderboardEntryMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + // Comment: Friendly name assigned to leader + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + // Comment: Friendly name assigned to leader + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(0, name, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + // Comment: Leader classification + /////////////////////////////////////////////////////////////////////// + FIT_SEGMENT_LEADERBOARD_TYPE GetType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + // Comment: Leader classification + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_SEGMENT_LEADERBOARD_TYPE type) + { + SetFieldENUMValue(1, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of group_primary_key field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGroupPrimaryKeyValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns group_primary_key field + // Comment: Primary user ID of this leader + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetGroupPrimaryKey(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set group_primary_key field + // Comment: Primary user ID of this leader + /////////////////////////////////////////////////////////////////////// + void SetGroupPrimaryKey(FIT_UINT32 groupPrimaryKey) + { + SetFieldUINT32Value(2, groupPrimaryKey, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityIdValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_id field + // Comment: ID of the activity associated with this leader time + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetActivityId(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_id field + // Comment: ID of the activity associated with this leader time + /////////////////////////////////////////////////////////////////////// + void SetActivityId(FIT_UINT32 activityId) + { + SetFieldUINT32Value(3, activityId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of segment_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSegmentTimeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns segment_time field + // Units: s + // Comment: Segment Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSegmentTime(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set segment_time field + // Units: s + // Comment: Segment Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + void SetSegmentTime(FIT_FLOAT32 segmentTime) + { + SetFieldFLOAT32Value(4, segmentTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_id_string field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityIdStringValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_id_string field + // Comment: String version of the activity_id. 21 characters long, express in decimal + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetActivityIdString(void) const + { + return GetFieldSTRINGValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_id_string field + // Comment: String version of the activity_id. 21 characters long, express in decimal + /////////////////////////////////////////////////////////////////////// + void SetActivityIdString(FIT_WSTRING activityIdString) + { + SetFieldSTRINGValue(5, activityIdString, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_LEADERBOARD_ENTRY_MESG_HPP) diff --git a/fit_segment_leaderboard_entry_mesg_listener.hpp b/fit_segment_leaderboard_entry_mesg_listener.hpp new file mode 100644 index 0000000..0129a84 --- /dev/null +++ b/fit_segment_leaderboard_entry_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_LEADERBOARD_ENTRY_MESG_LISTENER_HPP) +#define FIT_SEGMENT_LEADERBOARD_ENTRY_MESG_LISTENER_HPP + +#include "fit_segment_leaderboard_entry_mesg.hpp" + +namespace fit +{ + +class SegmentLeaderboardEntryMesgListener +{ +public: + virtual ~SegmentLeaderboardEntryMesgListener() {} + virtual void OnMesg(SegmentLeaderboardEntryMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_LEADERBOARD_ENTRY_MESG_LISTENER_HPP) diff --git a/fit_segment_point_mesg.hpp b/fit_segment_point_mesg.hpp new file mode 100644 index 0000000..04da30d --- /dev/null +++ b/fit_segment_point_mesg.hpp @@ -0,0 +1,294 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_POINT_MESG_HPP) +#define FIT_SEGMENT_POINT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SegmentPointMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 PositionLat = 1; + static const FIT_UINT8 PositionLong = 2; + static const FIT_UINT8 Distance = 3; + static const FIT_UINT8 Altitude = 4; + static const FIT_UINT8 LeaderTime = 5; + static const FIT_UINT8 EnhancedAltitude = 6; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SegmentPointMesg(void) : Mesg(Profile::MESG_SEGMENT_POINT) + { + } + + SegmentPointMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLatValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLat(void) const + { + return GetFieldSINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLat(FIT_SINT32 positionLat) + { + SetFieldSINT32Value(1, positionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionLongValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetPositionLong(void) const + { + return GetFieldSINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetPositionLong(FIT_SINT32 positionLong) + { + SetFieldSINT32Value(2, positionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance field + // Units: m + // Comment: Accumulated distance along the segment at the described point + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDistance(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance field + // Units: m + // Comment: Accumulated distance along the segment at the described point + /////////////////////////////////////////////////////////////////////// + void SetDistance(FIT_FLOAT32 distance) + { + SetFieldFLOAT32Value(3, distance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAltitudeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns altitude field + // Units: m + // Comment: Accumulated altitude along the segment at the described point + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAltitude(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set altitude field + // Units: m + // Comment: Accumulated altitude along the segment at the described point + /////////////////////////////////////////////////////////////////////// + void SetAltitude(FIT_FLOAT32 altitude) + { + SetFieldFLOAT32Value(4, altitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of leader_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumLeaderTime(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of leader_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeaderTimeValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns leader_time field + // Units: s + // Comment: Accumualted time each leader board member required to reach the described point. This value is zero for all leader board members at the starting point of the segment. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLeaderTime(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set leader_time field + // Units: s + // Comment: Accumualted time each leader board member required to reach the described point. This value is zero for all leader board members at the starting point of the segment. + /////////////////////////////////////////////////////////////////////// + void SetLeaderTime(FIT_UINT8 index, FIT_FLOAT32 leaderTime) + { + SetFieldFLOAT32Value(5, leaderTime, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAltitudeValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_altitude field + // Units: m + // Comment: Accumulated altitude along the segment at the described point + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAltitude(void) const + { + return GetFieldFLOAT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_altitude field + // Units: m + // Comment: Accumulated altitude along the segment at the described point + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAltitude(FIT_FLOAT32 enhancedAltitude) + { + SetFieldFLOAT32Value(6, enhancedAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_POINT_MESG_HPP) diff --git a/fit_segment_point_mesg_listener.hpp b/fit_segment_point_mesg_listener.hpp new file mode 100644 index 0000000..f3317ed --- /dev/null +++ b/fit_segment_point_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SEGMENT_POINT_MESG_LISTENER_HPP) +#define FIT_SEGMENT_POINT_MESG_LISTENER_HPP + +#include "fit_segment_point_mesg.hpp" + +namespace fit +{ + +class SegmentPointMesgListener +{ +public: + virtual ~SegmentPointMesgListener() {} + virtual void OnMesg(SegmentPointMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SEGMENT_POINT_MESG_LISTENER_HPP) diff --git a/fit_session_mesg.hpp b/fit_session_mesg.hpp new file mode 100644 index 0000000..87867fe --- /dev/null +++ b/fit_session_mesg.hpp @@ -0,0 +1,5719 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SESSION_MESG_HPP) +#define FIT_SESSION_MESG_HPP + +#include "fit_mesg.hpp" +#include "fit_mesg_with_event.hpp" + +namespace fit +{ + +class SessionMesg : public Mesg, public MesgWithEvent +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Event = 0; + static const FIT_UINT8 EventType = 1; + static const FIT_UINT8 StartTime = 2; + static const FIT_UINT8 StartPositionLat = 3; + static const FIT_UINT8 StartPositionLong = 4; + static const FIT_UINT8 Sport = 5; + static const FIT_UINT8 SubSport = 6; + static const FIT_UINT8 TotalElapsedTime = 7; + static const FIT_UINT8 TotalTimerTime = 8; + static const FIT_UINT8 TotalDistance = 9; + static const FIT_UINT8 TotalCycles = 10; + static const FIT_UINT8 TotalCalories = 11; + static const FIT_UINT8 TotalFatCalories = 13; + static const FIT_UINT8 AvgSpeed = 14; + static const FIT_UINT8 MaxSpeed = 15; + static const FIT_UINT8 AvgHeartRate = 16; + static const FIT_UINT8 MaxHeartRate = 17; + static const FIT_UINT8 AvgCadence = 18; + static const FIT_UINT8 MaxCadence = 19; + static const FIT_UINT8 AvgPower = 20; + static const FIT_UINT8 MaxPower = 21; + static const FIT_UINT8 TotalAscent = 22; + static const FIT_UINT8 TotalDescent = 23; + static const FIT_UINT8 TotalTrainingEffect = 24; + static const FIT_UINT8 FirstLapIndex = 25; + static const FIT_UINT8 NumLaps = 26; + static const FIT_UINT8 EventGroup = 27; + static const FIT_UINT8 Trigger = 28; + static const FIT_UINT8 NecLat = 29; + static const FIT_UINT8 NecLong = 30; + static const FIT_UINT8 SwcLat = 31; + static const FIT_UINT8 SwcLong = 32; + static const FIT_UINT8 NumLengths = 33; + static const FIT_UINT8 NormalizedPower = 34; + static const FIT_UINT8 TrainingStressScore = 35; + static const FIT_UINT8 IntensityFactor = 36; + static const FIT_UINT8 LeftRightBalance = 37; + static const FIT_UINT8 EndPositionLat = 38; + static const FIT_UINT8 EndPositionLong = 39; + static const FIT_UINT8 AvgStrokeCount = 41; + static const FIT_UINT8 AvgStrokeDistance = 42; + static const FIT_UINT8 SwimStroke = 43; + static const FIT_UINT8 PoolLength = 44; + static const FIT_UINT8 ThresholdPower = 45; + static const FIT_UINT8 PoolLengthUnit = 46; + static const FIT_UINT8 NumActiveLengths = 47; + static const FIT_UINT8 TotalWork = 48; + static const FIT_UINT8 AvgAltitude = 49; + static const FIT_UINT8 MaxAltitude = 50; + static const FIT_UINT8 GpsAccuracy = 51; + static const FIT_UINT8 AvgGrade = 52; + static const FIT_UINT8 AvgPosGrade = 53; + static const FIT_UINT8 AvgNegGrade = 54; + static const FIT_UINT8 MaxPosGrade = 55; + static const FIT_UINT8 MaxNegGrade = 56; + static const FIT_UINT8 AvgTemperature = 57; + static const FIT_UINT8 MaxTemperature = 58; + static const FIT_UINT8 TotalMovingTime = 59; + static const FIT_UINT8 AvgPosVerticalSpeed = 60; + static const FIT_UINT8 AvgNegVerticalSpeed = 61; + static const FIT_UINT8 MaxPosVerticalSpeed = 62; + static const FIT_UINT8 MaxNegVerticalSpeed = 63; + static const FIT_UINT8 MinHeartRate = 64; + static const FIT_UINT8 TimeInHrZone = 65; + static const FIT_UINT8 TimeInSpeedZone = 66; + static const FIT_UINT8 TimeInCadenceZone = 67; + static const FIT_UINT8 TimeInPowerZone = 68; + static const FIT_UINT8 AvgLapTime = 69; + static const FIT_UINT8 BestLapIndex = 70; + static const FIT_UINT8 MinAltitude = 71; + static const FIT_UINT8 PlayerScore = 82; + static const FIT_UINT8 OpponentScore = 83; + static const FIT_UINT8 OpponentName = 84; + static const FIT_UINT8 StrokeCount = 85; + static const FIT_UINT8 ZoneCount = 86; + static const FIT_UINT8 MaxBallSpeed = 87; + static const FIT_UINT8 AvgBallSpeed = 88; + static const FIT_UINT8 AvgVerticalOscillation = 89; + static const FIT_UINT8 AvgStanceTimePercent = 90; + static const FIT_UINT8 AvgStanceTime = 91; + static const FIT_UINT8 AvgFractionalCadence = 92; + static const FIT_UINT8 MaxFractionalCadence = 93; + static const FIT_UINT8 TotalFractionalCycles = 94; + static const FIT_UINT8 AvgTotalHemoglobinConc = 95; + static const FIT_UINT8 MinTotalHemoglobinConc = 96; + static const FIT_UINT8 MaxTotalHemoglobinConc = 97; + static const FIT_UINT8 AvgSaturatedHemoglobinPercent = 98; + static const FIT_UINT8 MinSaturatedHemoglobinPercent = 99; + static const FIT_UINT8 MaxSaturatedHemoglobinPercent = 100; + static const FIT_UINT8 AvgLeftTorqueEffectiveness = 101; + static const FIT_UINT8 AvgRightTorqueEffectiveness = 102; + static const FIT_UINT8 AvgLeftPedalSmoothness = 103; + static const FIT_UINT8 AvgRightPedalSmoothness = 104; + static const FIT_UINT8 AvgCombinedPedalSmoothness = 105; + static const FIT_UINT8 SportProfileName = 110; + static const FIT_UINT8 SportIndex = 111; + static const FIT_UINT8 TimeStanding = 112; + static const FIT_UINT8 StandCount = 113; + static const FIT_UINT8 AvgLeftPco = 114; + static const FIT_UINT8 AvgRightPco = 115; + static const FIT_UINT8 AvgLeftPowerPhase = 116; + static const FIT_UINT8 AvgLeftPowerPhasePeak = 117; + static const FIT_UINT8 AvgRightPowerPhase = 118; + static const FIT_UINT8 AvgRightPowerPhasePeak = 119; + static const FIT_UINT8 AvgPowerPosition = 120; + static const FIT_UINT8 MaxPowerPosition = 121; + static const FIT_UINT8 AvgCadencePosition = 122; + static const FIT_UINT8 MaxCadencePosition = 123; + static const FIT_UINT8 EnhancedAvgSpeed = 124; + static const FIT_UINT8 EnhancedMaxSpeed = 125; + static const FIT_UINT8 EnhancedAvgAltitude = 126; + static const FIT_UINT8 EnhancedMinAltitude = 127; + static const FIT_UINT8 EnhancedMaxAltitude = 128; + static const FIT_UINT8 AvgLevMotorPower = 129; + static const FIT_UINT8 MaxLevMotorPower = 130; + static const FIT_UINT8 LevBatteryConsumption = 131; + static const FIT_UINT8 AvgVerticalRatio = 132; + static const FIT_UINT8 AvgStanceTimeBalance = 133; + static const FIT_UINT8 AvgStepLength = 134; + static const FIT_UINT8 TotalAnaerobicTrainingEffect = 137; + static const FIT_UINT8 AvgVam = 139; + static const FIT_UINT8 AvgDepth = 140; + static const FIT_UINT8 MaxDepth = 141; + static const FIT_UINT8 SurfaceInterval = 142; + static const FIT_UINT8 StartCns = 143; + static const FIT_UINT8 EndCns = 144; + static const FIT_UINT8 StartN2 = 145; + static const FIT_UINT8 EndN2 = 146; + static const FIT_UINT8 AvgRespirationRate = 147; + static const FIT_UINT8 MaxRespirationRate = 148; + static const FIT_UINT8 MinRespirationRate = 149; + static const FIT_UINT8 MinTemperature = 150; + static const FIT_UINT8 O2Toxicity = 155; + static const FIT_UINT8 DiveNumber = 156; + static const FIT_UINT8 TrainingLoadPeak = 168; + static const FIT_UINT8 EnhancedAvgRespirationRate = 169; + static const FIT_UINT8 EnhancedMaxRespirationRate = 170; + static const FIT_UINT8 EnhancedMinRespirationRate = 180; + static const FIT_UINT8 TotalGrit = 181; + static const FIT_UINT8 TotalFlow = 182; + static const FIT_UINT8 JumpCount = 183; + static const FIT_UINT8 AvgGrit = 186; + static const FIT_UINT8 AvgFlow = 187; + static const FIT_UINT8 WorkoutFeel = 192; + static const FIT_UINT8 WorkoutRpe = 193; + static const FIT_UINT8 AvgSpo2 = 194; + static const FIT_UINT8 AvgStress = 195; + static const FIT_UINT8 SdrrHrv = 197; + static const FIT_UINT8 RmssdHrv = 198; + static const FIT_UINT8 TotalFractionalAscent = 199; + static const FIT_UINT8 TotalFractionalDescent = 200; + static const FIT_UINT8 AvgCoreTemperature = 208; + static const FIT_UINT8 MinCoreTemperature = 209; + static const FIT_UINT8 MaxCoreTemperature = 210; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SessionMesg(void) : Mesg(Profile::MESG_SESSION) + { + } + + SessionMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + // Comment: Selected bit is set for the current session. + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + // Comment: Selected bit is set for the current session. + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event field + // Comment: session + /////////////////////////////////////////////////////////////////////// + FIT_EVENT GetEvent(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event field + // Comment: session + /////////////////////////////////////////////////////////////////////// + void SetEvent(FIT_EVENT event) + { + SetFieldENUMValue(0, event, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_type field + // Comment: stop + /////////////////////////////////////////////////////////////////////// + FIT_EVENT_TYPE GetEventType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_type field + // Comment: stop + /////////////////////////////////////////////////////////////////////// + void SetEventType(FIT_EVENT_TYPE eventType) + { + SetFieldENUMValue(1, eventType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTime(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_time field + /////////////////////////////////////////////////////////////////////// + void SetStartTime(FIT_DATE_TIME startTime) + { + SetFieldUINT32Value(2, startTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLatValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLat(void) const + { + return GetFieldSINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLat(FIT_SINT32 startPositionLat) + { + SetFieldSINT32Value(3, startPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLongValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLong(void) const + { + return GetFieldSINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLong(FIT_SINT32 startPositionLong) + { + SetFieldSINT32Value(4, startPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(5, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(6, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_elapsed_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalElapsedTimeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_elapsed_time field + // Units: s + // Comment: Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalElapsedTime(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_elapsed_time field + // Units: s + // Comment: Time (includes pauses) + /////////////////////////////////////////////////////////////////////// + void SetTotalElapsedTime(FIT_FLOAT32 totalElapsedTime) + { + SetFieldFLOAT32Value(7, totalElapsedTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + // Comment: Timer Time (excludes pauses) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + // Comment: Timer Time (excludes pauses) + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(8, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDistanceValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalDistance(void) const + { + return GetFieldFLOAT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDistance(FIT_FLOAT32 totalDistance) + { + SetFieldFLOAT32Value(9, totalDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCyclesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalCycles(void) const + { + return GetFieldUINT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_cycles field + // Units: cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalCycles(FIT_UINT32 totalCycles) + { + SetFieldUINT32Value(10, totalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_strides field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalStridesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns total_strides field + // Units: strides + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalStrides(void) const + { + return GetFieldUINT32Value(10, 0, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_strides field + // Units: strides + /////////////////////////////////////////////////////////////////////// + void SetTotalStrides(FIT_UINT32 totalStrides) + { + SetFieldUINT32Value(10, totalStrides, 0, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STRIDES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_strokes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalStrokesValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalStrokes(void) const + { + return GetFieldUINT32Value(10, 0, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_strokes field + // Units: strokes + /////////////////////////////////////////////////////////////////////// + void SetTotalStrokes(FIT_UINT32 totalStrokes) + { + SetFieldUINT32Value(10, totalStrokes, 0, (FIT_UINT16) Profile::SESSION_MESG_TOTAL_CYCLES_FIELD_TOTAL_STROKES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCaloriesValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalCalories(void) const + { + return GetFieldUINT16Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalCalories(FIT_UINT16 totalCalories) + { + SetFieldUINT16Value(11, totalCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fat_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFatCaloriesValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fat_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalFatCalories(void) const + { + return GetFieldUINT16Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fat_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalFatCalories(FIT_UINT16 totalFatCalories) + { + SetFieldUINT16Value(13, totalFatCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + // Comment: total_distance / total_timer_time + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + // Comment: total_distance / total_timer_time + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(14, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSpeedValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSpeed(void) const + { + return GetFieldFLOAT32Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxSpeed(FIT_FLOAT32 maxSpeed) + { + SetFieldFLOAT32Value(15, maxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgHeartRateValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_heart_rate field + // Units: bpm + // Comment: average heart rate (excludes pause time) + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgHeartRate(void) const + { + return GetFieldUINT8Value(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_heart_rate field + // Units: bpm + // Comment: average heart rate (excludes pause time) + /////////////////////////////////////////////////////////////////////// + void SetAvgHeartRate(FIT_UINT8 avgHeartRate) + { + SetFieldUINT8Value(16, avgHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxHeartRateValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxHeartRate(void) const + { + return GetFieldUINT8Value(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMaxHeartRate(FIT_UINT8 maxHeartRate) + { + SetFieldUINT8Value(17, maxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCadenceValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_cadence field + // Units: rpm + // Comment: total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgCadence(void) const + { + return GetFieldUINT8Value(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_cadence field + // Units: rpm + // Comment: total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + void SetAvgCadence(FIT_UINT8 avgCadence) + { + SetFieldUINT8Value(18, avgCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_running_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRunningCadenceValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SESSION_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SESSION_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns avg_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgRunningCadence(void) const + { + return GetFieldUINT8Value(18, 0, (FIT_UINT16) Profile::SESSION_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + void SetAvgRunningCadence(FIT_UINT8 avgRunningCadence) + { + SetFieldUINT8Value(18, avgRunningCadence, 0, (FIT_UINT16) Profile::SESSION_MESG_AVG_CADENCE_FIELD_AVG_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCadenceValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxCadence(void) const + { + return GetFieldUINT8Value(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_cadence field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetMaxCadence(FIT_UINT8 maxCadence) + { + SetFieldUINT8Value(19, maxCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_running_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxRunningCadenceValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SESSION_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SESSION_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns max_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxRunningCadence(void) const + { + return GetFieldUINT8Value(19, 0, (FIT_UINT16) Profile::SESSION_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_running_cadence field + // Units: strides/min + /////////////////////////////////////////////////////////////////////// + void SetMaxRunningCadence(FIT_UINT8 maxRunningCadence) + { + SetFieldUINT8Value(19, maxRunningCadence, 0, (FIT_UINT16) Profile::SESSION_MESG_MAX_CADENCE_FIELD_MAX_RUNNING_CADENCE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPowerValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_power field + // Units: watts + // Comment: total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgPower(void) const + { + return GetFieldUINT16Value(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_power field + // Units: watts + // Comment: total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time + /////////////////////////////////////////////////////////////////////// + void SetAvgPower(FIT_UINT16 avgPower) + { + SetFieldUINT16Value(20, avgPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPowerValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPower(void) const + { + return GetFieldUINT16Value(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetMaxPower(FIT_UINT16 maxPower) + { + SetFieldUINT16Value(21, maxPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalAscentValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalAscent(void) const + { + return GetFieldUINT16Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalAscent(FIT_UINT16 totalAscent) + { + SetFieldUINT16Value(22, totalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDescentValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalDescent(void) const + { + return GetFieldUINT16Value(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDescent(FIT_UINT16 totalDescent) + { + SetFieldUINT16Value(23, totalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_training_effect field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTrainingEffectValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_training_effect field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTrainingEffect(void) const + { + return GetFieldFLOAT32Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_training_effect field + /////////////////////////////////////////////////////////////////////// + void SetTotalTrainingEffect(FIT_FLOAT32 totalTrainingEffect) + { + SetFieldFLOAT32Value(24, totalTrainingEffect, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of first_lap_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFirstLapIndexValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns first_lap_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetFirstLapIndex(void) const + { + return GetFieldUINT16Value(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set first_lap_index field + /////////////////////////////////////////////////////////////////////// + void SetFirstLapIndex(FIT_UINT16 firstLapIndex) + { + SetFieldUINT16Value(25, firstLapIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_laps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumLapsValid() const + { + const Field* field = GetField(26); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_laps field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumLaps(void) const + { + return GetFieldUINT16Value(26, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_laps field + /////////////////////////////////////////////////////////////////////// + void SetNumLaps(FIT_UINT16 numLaps) + { + SetFieldUINT16Value(26, numLaps, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of event_group field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEventGroupValid() const + { + const Field* field = GetField(27); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns event_group field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEventGroup(void) const + { + return GetFieldUINT8Value(27, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set event_group field + /////////////////////////////////////////////////////////////////////// + void SetEventGroup(FIT_UINT8 eventGroup) + { + SetFieldUINT8Value(27, eventGroup, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of trigger field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTriggerValid() const + { + const Field* field = GetField(28); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns trigger field + /////////////////////////////////////////////////////////////////////// + FIT_SESSION_TRIGGER GetTrigger(void) const + { + return GetFieldENUMValue(28, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set trigger field + /////////////////////////////////////////////////////////////////////// + void SetTrigger(FIT_SESSION_TRIGGER trigger) + { + SetFieldENUMValue(28, trigger, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of nec_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNecLatValid() const + { + const Field* field = GetField(29); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns nec_lat field + // Units: semicircles + // Comment: North east corner latitude + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetNecLat(void) const + { + return GetFieldSINT32Value(29, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set nec_lat field + // Units: semicircles + // Comment: North east corner latitude + /////////////////////////////////////////////////////////////////////// + void SetNecLat(FIT_SINT32 necLat) + { + SetFieldSINT32Value(29, necLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of nec_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNecLongValid() const + { + const Field* field = GetField(30); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns nec_long field + // Units: semicircles + // Comment: North east corner longitude + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetNecLong(void) const + { + return GetFieldSINT32Value(30, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set nec_long field + // Units: semicircles + // Comment: North east corner longitude + /////////////////////////////////////////////////////////////////////// + void SetNecLong(FIT_SINT32 necLong) + { + SetFieldSINT32Value(30, necLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swc_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwcLatValid() const + { + const Field* field = GetField(31); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swc_lat field + // Units: semicircles + // Comment: South west corner latitude + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetSwcLat(void) const + { + return GetFieldSINT32Value(31, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swc_lat field + // Units: semicircles + // Comment: South west corner latitude + /////////////////////////////////////////////////////////////////////// + void SetSwcLat(FIT_SINT32 swcLat) + { + SetFieldSINT32Value(31, swcLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swc_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwcLongValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swc_long field + // Units: semicircles + // Comment: South west corner longitude + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetSwcLong(void) const + { + return GetFieldSINT32Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swc_long field + // Units: semicircles + // Comment: South west corner longitude + /////////////////////////////////////////////////////////////////////// + void SetSwcLong(FIT_SINT32 swcLong) + { + SetFieldSINT32Value(32, swcLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_lengths field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumLengthsValid() const + { + const Field* field = GetField(33); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_lengths field + // Units: lengths + // Comment: # of lengths of swim pool + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumLengths(void) const + { + return GetFieldUINT16Value(33, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_lengths field + // Units: lengths + // Comment: # of lengths of swim pool + /////////////////////////////////////////////////////////////////////// + void SetNumLengths(FIT_UINT16 numLengths) + { + SetFieldUINT16Value(33, numLengths, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of normalized_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNormalizedPowerValid() const + { + const Field* field = GetField(34); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns normalized_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNormalizedPower(void) const + { + return GetFieldUINT16Value(34, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set normalized_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetNormalizedPower(FIT_UINT16 normalizedPower) + { + SetFieldUINT16Value(34, normalizedPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of training_stress_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTrainingStressScoreValid() const + { + const Field* field = GetField(35); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns training_stress_score field + // Units: tss + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTrainingStressScore(void) const + { + return GetFieldFLOAT32Value(35, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set training_stress_score field + // Units: tss + /////////////////////////////////////////////////////////////////////// + void SetTrainingStressScore(FIT_FLOAT32 trainingStressScore) + { + SetFieldFLOAT32Value(35, trainingStressScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of intensity_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIntensityFactorValid() const + { + const Field* field = GetField(36); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns intensity_factor field + // Units: if + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetIntensityFactor(void) const + { + return GetFieldFLOAT32Value(36, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set intensity_factor field + // Units: if + /////////////////////////////////////////////////////////////////////// + void SetIntensityFactor(FIT_FLOAT32 intensityFactor) + { + SetFieldFLOAT32Value(36, intensityFactor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of left_right_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLeftRightBalanceValid() const + { + const Field* field = GetField(37); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns left_right_balance field + /////////////////////////////////////////////////////////////////////// + FIT_LEFT_RIGHT_BALANCE_100 GetLeftRightBalance(void) const + { + return GetFieldUINT16Value(37, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set left_right_balance field + /////////////////////////////////////////////////////////////////////// + void SetLeftRightBalance(FIT_LEFT_RIGHT_BALANCE_100 leftRightBalance) + { + SetFieldUINT16Value(37, leftRightBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLatValid() const + { + const Field* field = GetField(38); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLat(void) const + { + return GetFieldSINT32Value(38, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLat(FIT_SINT32 endPositionLat) + { + SetFieldSINT32Value(38, endPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLongValid() const + { + const Field* field = GetField(39); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLong(void) const + { + return GetFieldSINT32Value(39, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLong(FIT_SINT32 endPositionLong) + { + SetFieldSINT32Value(39, endPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stroke_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStrokeCountValid() const + { + const Field* field = GetField(41); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stroke_count field + // Units: strokes/lap + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStrokeCount(void) const + { + return GetFieldFLOAT32Value(41, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stroke_count field + // Units: strokes/lap + /////////////////////////////////////////////////////////////////////// + void SetAvgStrokeCount(FIT_FLOAT32 avgStrokeCount) + { + SetFieldFLOAT32Value(41, avgStrokeCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stroke_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStrokeDistanceValid() const + { + const Field* field = GetField(42); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stroke_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStrokeDistance(void) const + { + return GetFieldFLOAT32Value(42, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stroke_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAvgStrokeDistance(FIT_FLOAT32 avgStrokeDistance) + { + SetFieldFLOAT32Value(42, avgStrokeDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of swim_stroke field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSwimStrokeValid() const + { + const Field* field = GetField(43); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns swim_stroke field + // Units: swim_stroke + /////////////////////////////////////////////////////////////////////// + FIT_SWIM_STROKE GetSwimStroke(void) const + { + return GetFieldENUMValue(43, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set swim_stroke field + // Units: swim_stroke + /////////////////////////////////////////////////////////////////////// + void SetSwimStroke(FIT_SWIM_STROKE swimStroke) + { + SetFieldENUMValue(43, swimStroke, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pool_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPoolLengthValid() const + { + const Field* field = GetField(44); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pool_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPoolLength(void) const + { + return GetFieldFLOAT32Value(44, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pool_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetPoolLength(FIT_FLOAT32 poolLength) + { + SetFieldFLOAT32Value(44, poolLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of threshold_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsThresholdPowerValid() const + { + const Field* field = GetField(45); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns threshold_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetThresholdPower(void) const + { + return GetFieldUINT16Value(45, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set threshold_power field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetThresholdPower(FIT_UINT16 thresholdPower) + { + SetFieldUINT16Value(45, thresholdPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pool_length_unit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPoolLengthUnitValid() const + { + const Field* field = GetField(46); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pool_length_unit field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetPoolLengthUnit(void) const + { + return GetFieldENUMValue(46, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pool_length_unit field + /////////////////////////////////////////////////////////////////////// + void SetPoolLengthUnit(FIT_DISPLAY_MEASURE poolLengthUnit) + { + SetFieldENUMValue(46, poolLengthUnit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_active_lengths field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumActiveLengthsValid() const + { + const Field* field = GetField(47); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_active_lengths field + // Units: lengths + // Comment: # of active lengths of swim pool + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumActiveLengths(void) const + { + return GetFieldUINT16Value(47, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_active_lengths field + // Units: lengths + // Comment: # of active lengths of swim pool + /////////////////////////////////////////////////////////////////////// + void SetNumActiveLengths(FIT_UINT16 numActiveLengths) + { + SetFieldUINT16Value(47, numActiveLengths, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_work field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalWorkValid() const + { + const Field* field = GetField(48); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_work field + // Units: J + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalWork(void) const + { + return GetFieldUINT32Value(48, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_work field + // Units: J + /////////////////////////////////////////////////////////////////////// + void SetTotalWork(FIT_UINT32 totalWork) + { + SetFieldUINT32Value(48, totalWork, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgAltitudeValid() const + { + const Field* field = GetField(49); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgAltitude(void) const + { + return GetFieldFLOAT32Value(49, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetAvgAltitude(FIT_FLOAT32 avgAltitude) + { + SetFieldFLOAT32Value(49, avgAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxAltitudeValid() const + { + const Field* field = GetField(50); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxAltitude(void) const + { + return GetFieldFLOAT32Value(50, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetMaxAltitude(FIT_FLOAT32 maxAltitude) + { + SetFieldFLOAT32Value(50, maxAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gps_accuracy field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGpsAccuracyValid() const + { + const Field* field = GetField(51); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetGpsAccuracy(void) const + { + return GetFieldUINT8Value(51, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gps_accuracy field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetGpsAccuracy(FIT_UINT8 gpsAccuracy) + { + SetFieldUINT8Value(51, gpsAccuracy, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgGradeValid() const + { + const Field* field = GetField(52); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgGrade(void) const + { + return GetFieldFLOAT32Value(52, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgGrade(FIT_FLOAT32 avgGrade) + { + SetFieldFLOAT32Value(52, avgGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pos_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPosGradeValid() const + { + const Field* field = GetField(53); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPosGrade(void) const + { + return GetFieldFLOAT32Value(53, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgPosGrade(FIT_FLOAT32 avgPosGrade) + { + SetFieldFLOAT32Value(53, avgPosGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_neg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgNegGradeValid() const + { + const Field* field = GetField(54); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgNegGrade(void) const + { + return GetFieldFLOAT32Value(54, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetAvgNegGrade(FIT_FLOAT32 avgNegGrade) + { + SetFieldFLOAT32Value(54, avgNegGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_pos_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPosGradeValid() const + { + const Field* field = GetField(55); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxPosGrade(void) const + { + return GetFieldFLOAT32Value(55, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_pos_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetMaxPosGrade(FIT_FLOAT32 maxPosGrade) + { + SetFieldFLOAT32Value(55, maxPosGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_neg_grade field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxNegGradeValid() const + { + const Field* field = GetField(56); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxNegGrade(void) const + { + return GetFieldFLOAT32Value(56, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_neg_grade field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetMaxNegGrade(FIT_FLOAT32 maxNegGrade) + { + SetFieldFLOAT32Value(56, maxNegGrade, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgTemperatureValid() const + { + const Field* field = GetField(57); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgTemperature(void) const + { + return GetFieldSINT8Value(57, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetAvgTemperature(FIT_SINT8 avgTemperature) + { + SetFieldSINT8Value(57, avgTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxTemperatureValid() const + { + const Field* field = GetField(58); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetMaxTemperature(void) const + { + return GetFieldSINT8Value(58, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMaxTemperature(FIT_SINT8 maxTemperature) + { + SetFieldSINT8Value(58, maxTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_moving_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalMovingTimeValid() const + { + const Field* field = GetField(59); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalMovingTime(void) const + { + return GetFieldFLOAT32Value(59, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalMovingTime(FIT_FLOAT32 totalMovingTime) + { + SetFieldFLOAT32Value(59, totalMovingTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_pos_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPosVerticalSpeedValid() const + { + const Field* field = GetField(60); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgPosVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(60, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgPosVerticalSpeed(FIT_FLOAT32 avgPosVerticalSpeed) + { + SetFieldFLOAT32Value(60, avgPosVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_neg_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgNegVerticalSpeedValid() const + { + const Field* field = GetField(61); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgNegVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(61, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgNegVerticalSpeed(FIT_FLOAT32 avgNegVerticalSpeed) + { + SetFieldFLOAT32Value(61, avgNegVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_pos_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPosVerticalSpeedValid() const + { + const Field* field = GetField(62); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxPosVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(62, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_pos_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxPosVerticalSpeed(FIT_FLOAT32 maxPosVerticalSpeed) + { + SetFieldFLOAT32Value(62, maxPosVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_neg_vertical_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxNegVerticalSpeedValid() const + { + const Field* field = GetField(63); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxNegVerticalSpeed(void) const + { + return GetFieldFLOAT32Value(63, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_neg_vertical_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxNegVerticalSpeed(FIT_FLOAT32 maxNegVerticalSpeed) + { + SetFieldFLOAT32Value(63, maxNegVerticalSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinHeartRateValid() const + { + const Field* field = GetField(64); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMinHeartRate(void) const + { + return GetFieldUINT8Value(64, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMinHeartRate(FIT_UINT8 minHeartRate) + { + SetFieldUINT8Value(64, minHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_hr_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInHrZone(void) const + { + return GetFieldNumValues(65, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_hr_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInHrZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(65); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInHrZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(65, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInHrZone(FIT_UINT8 index, FIT_FLOAT32 timeInHrZone) + { + SetFieldFLOAT32Value(65, timeInHrZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_speed_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInSpeedZone(void) const + { + return GetFieldNumValues(66, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_speed_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInSpeedZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(66); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInSpeedZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(66, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInSpeedZone(FIT_UINT8 index, FIT_FLOAT32 timeInSpeedZone) + { + SetFieldFLOAT32Value(66, timeInSpeedZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_cadence_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInCadenceZone(void) const + { + return GetFieldNumValues(67, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_cadence_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInCadenceZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(67); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInCadenceZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(67, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInCadenceZone(FIT_UINT8 index, FIT_FLOAT32 timeInCadenceZone) + { + SetFieldFLOAT32Value(67, timeInCadenceZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_power_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInPowerZone(void) const + { + return GetFieldNumValues(68, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_power_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInPowerZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(68); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInPowerZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(68, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInPowerZone(FIT_UINT8 index, FIT_FLOAT32 timeInPowerZone) + { + SetFieldFLOAT32Value(68, timeInPowerZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_lap_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLapTimeValid() const + { + const Field* field = GetField(69); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_lap_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLapTime(void) const + { + return GetFieldFLOAT32Value(69, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_lap_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetAvgLapTime(FIT_FLOAT32 avgLapTime) + { + SetFieldFLOAT32Value(69, avgLapTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of best_lap_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBestLapIndexValid() const + { + const Field* field = GetField(70); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns best_lap_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetBestLapIndex(void) const + { + return GetFieldUINT16Value(70, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set best_lap_index field + /////////////////////////////////////////////////////////////////////// + void SetBestLapIndex(FIT_UINT16 bestLapIndex) + { + SetFieldUINT16Value(70, bestLapIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinAltitudeValid() const + { + const Field* field = GetField(71); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinAltitude(void) const + { + return GetFieldFLOAT32Value(71, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetMinAltitude(FIT_FLOAT32 minAltitude) + { + SetFieldFLOAT32Value(71, minAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of player_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPlayerScoreValid() const + { + const Field* field = GetField(82); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns player_score field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPlayerScore(void) const + { + return GetFieldUINT16Value(82, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set player_score field + /////////////////////////////////////////////////////////////////////// + void SetPlayerScore(FIT_UINT16 playerScore) + { + SetFieldUINT16Value(82, playerScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of opponent_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOpponentScoreValid() const + { + const Field* field = GetField(83); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns opponent_score field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetOpponentScore(void) const + { + return GetFieldUINT16Value(83, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set opponent_score field + /////////////////////////////////////////////////////////////////////// + void SetOpponentScore(FIT_UINT16 opponentScore) + { + SetFieldUINT16Value(83, opponentScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of opponent_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOpponentNameValid() const + { + const Field* field = GetField(84); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns opponent_name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetOpponentName(void) const + { + return GetFieldSTRINGValue(84, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set opponent_name field + /////////////////////////////////////////////////////////////////////// + void SetOpponentName(FIT_WSTRING opponentName) + { + SetFieldSTRINGValue(84, opponentName, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of stroke_count + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumStrokeCount(void) const + { + return GetFieldNumValues(85, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stroke_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStrokeCountValid(FIT_UINT8 index) const + { + const Field* field = GetField(85); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stroke_count field + // Units: counts + // Comment: stroke_type enum used as the index + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStrokeCount(FIT_UINT8 index) const + { + return GetFieldUINT16Value(85, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stroke_count field + // Units: counts + // Comment: stroke_type enum used as the index + /////////////////////////////////////////////////////////////////////// + void SetStrokeCount(FIT_UINT8 index, FIT_UINT16 strokeCount) + { + SetFieldUINT16Value(85, strokeCount, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of zone_count + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumZoneCount(void) const + { + return GetFieldNumValues(86, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of zone_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsZoneCountValid(FIT_UINT8 index) const + { + const Field* field = GetField(86); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns zone_count field + // Units: counts + // Comment: zone number used as the index + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetZoneCount(FIT_UINT8 index) const + { + return GetFieldUINT16Value(86, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set zone_count field + // Units: counts + // Comment: zone number used as the index + /////////////////////////////////////////////////////////////////////// + void SetZoneCount(FIT_UINT8 index, FIT_UINT16 zoneCount) + { + SetFieldUINT16Value(86, zoneCount, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_ball_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxBallSpeedValid() const + { + const Field* field = GetField(87); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_ball_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxBallSpeed(void) const + { + return GetFieldFLOAT32Value(87, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_ball_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxBallSpeed(FIT_FLOAT32 maxBallSpeed) + { + SetFieldFLOAT32Value(87, maxBallSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_ball_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgBallSpeedValid() const + { + const Field* field = GetField(88); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_ball_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgBallSpeed(void) const + { + return GetFieldFLOAT32Value(88, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_ball_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgBallSpeed(FIT_FLOAT32 avgBallSpeed) + { + SetFieldFLOAT32Value(88, avgBallSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vertical_oscillation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVerticalOscillationValid() const + { + const Field* field = GetField(89); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vertical_oscillation field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVerticalOscillation(void) const + { + return GetFieldFLOAT32Value(89, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vertical_oscillation field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetAvgVerticalOscillation(FIT_FLOAT32 avgVerticalOscillation) + { + SetFieldFLOAT32Value(89, avgVerticalOscillation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stance_time_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStanceTimePercentValid() const + { + const Field* field = GetField(90); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stance_time_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStanceTimePercent(void) const + { + return GetFieldFLOAT32Value(90, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stance_time_percent field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgStanceTimePercent(FIT_FLOAT32 avgStanceTimePercent) + { + SetFieldFLOAT32Value(90, avgStanceTimePercent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stance_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStanceTimeValid() const + { + const Field* field = GetField(91); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stance_time field + // Units: ms + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStanceTime(void) const + { + return GetFieldFLOAT32Value(91, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stance_time field + // Units: ms + /////////////////////////////////////////////////////////////////////// + void SetAvgStanceTime(FIT_FLOAT32 avgStanceTime) + { + SetFieldFLOAT32Value(91, avgStanceTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgFractionalCadenceValid() const + { + const Field* field = GetField(92); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_fractional_cadence field + // Units: rpm + // Comment: fractional part of the avg_cadence + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgFractionalCadence(void) const + { + return GetFieldFLOAT32Value(92, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_fractional_cadence field + // Units: rpm + // Comment: fractional part of the avg_cadence + /////////////////////////////////////////////////////////////////////// + void SetAvgFractionalCadence(FIT_FLOAT32 avgFractionalCadence) + { + SetFieldFLOAT32Value(92, avgFractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_fractional_cadence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxFractionalCadenceValid() const + { + const Field* field = GetField(93); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_fractional_cadence field + // Units: rpm + // Comment: fractional part of the max_cadence + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxFractionalCadence(void) const + { + return GetFieldFLOAT32Value(93, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_fractional_cadence field + // Units: rpm + // Comment: fractional part of the max_cadence + /////////////////////////////////////////////////////////////////////// + void SetMaxFractionalCadence(FIT_FLOAT32 maxFractionalCadence) + { + SetFieldFLOAT32Value(93, maxFractionalCadence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_cycles field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalCyclesValid() const + { + const Field* field = GetField(94); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_cycles field + // Units: cycles + // Comment: fractional part of the total_cycles + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalCycles(void) const + { + return GetFieldFLOAT32Value(94, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_cycles field + // Units: cycles + // Comment: fractional part of the total_cycles + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalCycles(FIT_FLOAT32 totalFractionalCycles) + { + SetFieldFLOAT32Value(94, totalFractionalCycles, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_total_hemoglobin_conc + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgTotalHemoglobinConc(void) const + { + return GetFieldNumValues(95, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgTotalHemoglobinConcValid(FIT_UINT8 index) const + { + const Field* field = GetField(95); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_total_hemoglobin_conc field + // Units: g/dL + // Comment: Avg saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgTotalHemoglobinConc(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(95, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_total_hemoglobin_conc field + // Units: g/dL + // Comment: Avg saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetAvgTotalHemoglobinConc(FIT_UINT8 index, FIT_FLOAT32 avgTotalHemoglobinConc) + { + SetFieldFLOAT32Value(95, avgTotalHemoglobinConc, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of min_total_hemoglobin_conc + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMinTotalHemoglobinConc(void) const + { + return GetFieldNumValues(96, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinTotalHemoglobinConcValid(FIT_UINT8 index) const + { + const Field* field = GetField(96); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_total_hemoglobin_conc field + // Units: g/dL + // Comment: Min saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinTotalHemoglobinConc(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(96, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_total_hemoglobin_conc field + // Units: g/dL + // Comment: Min saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetMinTotalHemoglobinConc(FIT_UINT8 index, FIT_FLOAT32 minTotalHemoglobinConc) + { + SetFieldFLOAT32Value(96, minTotalHemoglobinConc, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_total_hemoglobin_conc + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxTotalHemoglobinConc(void) const + { + return GetFieldNumValues(97, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_total_hemoglobin_conc field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxTotalHemoglobinConcValid(FIT_UINT8 index) const + { + const Field* field = GetField(97); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_total_hemoglobin_conc field + // Units: g/dL + // Comment: Max saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxTotalHemoglobinConc(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(97, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_total_hemoglobin_conc field + // Units: g/dL + // Comment: Max saturated and unsaturated hemoglobin + /////////////////////////////////////////////////////////////////////// + void SetMaxTotalHemoglobinConc(FIT_UINT8 index, FIT_FLOAT32 maxTotalHemoglobinConc) + { + SetFieldFLOAT32Value(97, maxTotalHemoglobinConc, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_saturated_hemoglobin_percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgSaturatedHemoglobinPercent(void) const + { + return GetFieldNumValues(98, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSaturatedHemoglobinPercentValid(FIT_UINT8 index) const + { + const Field* field = GetField(98); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_saturated_hemoglobin_percent field + // Units: % + // Comment: Avg percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSaturatedHemoglobinPercent(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(98, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_saturated_hemoglobin_percent field + // Units: % + // Comment: Avg percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetAvgSaturatedHemoglobinPercent(FIT_UINT8 index, FIT_FLOAT32 avgSaturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(98, avgSaturatedHemoglobinPercent, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of min_saturated_hemoglobin_percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMinSaturatedHemoglobinPercent(void) const + { + return GetFieldNumValues(99, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinSaturatedHemoglobinPercentValid(FIT_UINT8 index) const + { + const Field* field = GetField(99); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_saturated_hemoglobin_percent field + // Units: % + // Comment: Min percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinSaturatedHemoglobinPercent(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(99, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_saturated_hemoglobin_percent field + // Units: % + // Comment: Min percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetMinSaturatedHemoglobinPercent(FIT_UINT8 index, FIT_FLOAT32 minSaturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(99, minSaturatedHemoglobinPercent, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_saturated_hemoglobin_percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxSaturatedHemoglobinPercent(void) const + { + return GetFieldNumValues(100, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_saturated_hemoglobin_percent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSaturatedHemoglobinPercentValid(FIT_UINT8 index) const + { + const Field* field = GetField(100); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_saturated_hemoglobin_percent field + // Units: % + // Comment: Max percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSaturatedHemoglobinPercent(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(100, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_saturated_hemoglobin_percent field + // Units: % + // Comment: Max percentage of hemoglobin saturated with oxygen + /////////////////////////////////////////////////////////////////////// + void SetMaxSaturatedHemoglobinPercent(FIT_UINT8 index, FIT_FLOAT32 maxSaturatedHemoglobinPercent) + { + SetFieldFLOAT32Value(100, maxSaturatedHemoglobinPercent, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftTorqueEffectivenessValid() const + { + const Field* field = GetField(101); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(101, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftTorqueEffectiveness(FIT_FLOAT32 avgLeftTorqueEffectiveness) + { + SetFieldFLOAT32Value(101, avgLeftTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_torque_effectiveness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightTorqueEffectivenessValid() const + { + const Field* field = GetField(102); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightTorqueEffectiveness(void) const + { + return GetFieldFLOAT32Value(102, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_torque_effectiveness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgRightTorqueEffectiveness(FIT_FLOAT32 avgRightTorqueEffectiveness) + { + SetFieldFLOAT32Value(102, avgRightTorqueEffectiveness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPedalSmoothnessValid() const + { + const Field* field = GetField(103); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(103, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPedalSmoothness(FIT_FLOAT32 avgLeftPedalSmoothness) + { + SetFieldFLOAT32Value(103, avgLeftPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPedalSmoothnessValid() const + { + const Field* field = GetField(104); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(104, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPedalSmoothness(FIT_FLOAT32 avgRightPedalSmoothness) + { + SetFieldFLOAT32Value(104, avgRightPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_combined_pedal_smoothness field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCombinedPedalSmoothnessValid() const + { + const Field* field = GetField(105); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgCombinedPedalSmoothness(void) const + { + return GetFieldFLOAT32Value(105, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_combined_pedal_smoothness field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgCombinedPedalSmoothness(FIT_FLOAT32 avgCombinedPedalSmoothness) + { + SetFieldFLOAT32Value(105, avgCombinedPedalSmoothness, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport_profile_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportProfileNameValid() const + { + const Field* field = GetField(110); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport_profile_name field + // Comment: Sport name from associated sport mesg + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetSportProfileName(void) const + { + return GetFieldSTRINGValue(110, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport_profile_name field + // Comment: Sport name from associated sport mesg + /////////////////////////////////////////////////////////////////////// + void SetSportProfileName(FIT_WSTRING sportProfileName) + { + SetFieldSTRINGValue(110, sportProfileName, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportIndexValid() const + { + const Field* field = GetField(111); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSportIndex(void) const + { + return GetFieldUINT8Value(111, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport_index field + /////////////////////////////////////////////////////////////////////// + void SetSportIndex(FIT_UINT8 sportIndex) + { + SetFieldUINT8Value(111, sportIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_standing field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeStandingValid() const + { + const Field* field = GetField(112); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_standing field + // Units: s + // Comment: Total time spend in the standing position + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeStanding(void) const + { + return GetFieldFLOAT32Value(112, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_standing field + // Units: s + // Comment: Total time spend in the standing position + /////////////////////////////////////////////////////////////////////// + void SetTimeStanding(FIT_FLOAT32 timeStanding) + { + SetFieldFLOAT32Value(112, timeStanding, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stand_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStandCountValid() const + { + const Field* field = GetField(113); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stand_count field + // Comment: Number of transitions to the standing state + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStandCount(void) const + { + return GetFieldUINT16Value(113, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stand_count field + // Comment: Number of transitions to the standing state + /////////////////////////////////////////////////////////////////////// + void SetStandCount(FIT_UINT16 standCount) + { + SetFieldUINT16Value(113, standCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPcoValid() const + { + const Field* field = GetField(114); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_pco field + // Units: mm + // Comment: Average platform center offset Left + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgLeftPco(void) const + { + return GetFieldSINT8Value(114, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_pco field + // Units: mm + // Comment: Average platform center offset Left + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPco(FIT_SINT8 avgLeftPco) + { + SetFieldSINT8Value(114, avgLeftPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_pco field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPcoValid() const + { + const Field* field = GetField(115); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_pco field + // Units: mm + // Comment: Average platform center offset Right + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetAvgRightPco(void) const + { + return GetFieldSINT8Value(115, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_pco field + // Units: mm + // Comment: Average platform center offset Right + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPco(FIT_SINT8 avgRightPco) + { + SetFieldSINT8Value(115, avgRightPco, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_left_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgLeftPowerPhase(void) const + { + return GetFieldNumValues(116, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(116); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_power_phase field + // Units: degrees + // Comment: Average left power phase angles. Indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(116, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_power_phase field + // Units: degrees + // Comment: Average left power phase angles. Indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPowerPhase(FIT_UINT8 index, FIT_FLOAT32 avgLeftPowerPhase) + { + SetFieldFLOAT32Value(116, avgLeftPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_left_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgLeftPowerPhasePeak(void) const + { + return GetFieldNumValues(117, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_left_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLeftPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(117); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_left_power_phase_peak field + // Units: degrees + // Comment: Average left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgLeftPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(117, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_left_power_phase_peak field + // Units: degrees + // Comment: Average left power phase peak angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgLeftPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 avgLeftPowerPhasePeak) + { + SetFieldFLOAT32Value(117, avgLeftPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_right_power_phase + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgRightPowerPhase(void) const + { + return GetFieldNumValues(118, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_power_phase field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPowerPhaseValid(FIT_UINT8 index) const + { + const Field* field = GetField(118); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_power_phase field + // Units: degrees + // Comment: Average right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPowerPhase(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(118, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_power_phase field + // Units: degrees + // Comment: Average right power phase angles. Data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPowerPhase(FIT_UINT8 index, FIT_FLOAT32 avgRightPowerPhase) + { + SetFieldFLOAT32Value(118, avgRightPowerPhase, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_right_power_phase_peak + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgRightPowerPhasePeak(void) const + { + return GetFieldNumValues(119, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_right_power_phase_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRightPowerPhasePeakValid(FIT_UINT8 index) const + { + const Field* field = GetField(119); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_right_power_phase_peak field + // Units: degrees + // Comment: Average right power phase peak angles data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgRightPowerPhasePeak(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(119, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_right_power_phase_peak field + // Units: degrees + // Comment: Average right power phase peak angles data value indexes defined by power_phase_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgRightPowerPhasePeak(FIT_UINT8 index, FIT_FLOAT32 avgRightPowerPhasePeak) + { + SetFieldFLOAT32Value(119, avgRightPowerPhasePeak, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_power_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgPowerPosition(void) const + { + return GetFieldNumValues(120, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_power_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgPowerPositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(120); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_power_position field + // Units: watts + // Comment: Average power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgPowerPosition(FIT_UINT8 index) const + { + return GetFieldUINT16Value(120, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_power_position field + // Units: watts + // Comment: Average power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgPowerPosition(FIT_UINT8 index, FIT_UINT16 avgPowerPosition) + { + SetFieldUINT16Value(120, avgPowerPosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_power_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxPowerPosition(void) const + { + return GetFieldNumValues(121, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_power_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxPowerPositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(121); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_power_position field + // Units: watts + // Comment: Maximum power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxPowerPosition(FIT_UINT8 index) const + { + return GetFieldUINT16Value(121, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_power_position field + // Units: watts + // Comment: Maximum power by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetMaxPowerPosition(FIT_UINT8 index, FIT_UINT16 maxPowerPosition) + { + SetFieldUINT16Value(121, maxPowerPosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of avg_cadence_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumAvgCadencePosition(void) const + { + return GetFieldNumValues(122, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_cadence_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCadencePositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(122); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_cadence_position field + // Units: rpm + // Comment: Average cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgCadencePosition(FIT_UINT8 index) const + { + return GetFieldUINT8Value(122, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_cadence_position field + // Units: rpm + // Comment: Average cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetAvgCadencePosition(FIT_UINT8 index, FIT_UINT8 avgCadencePosition) + { + SetFieldUINT8Value(122, avgCadencePosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of max_cadence_position + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumMaxCadencePosition(void) const + { + return GetFieldNumValues(123, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_cadence_position field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCadencePositionValid(FIT_UINT8 index) const + { + const Field* field = GetField(123); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_cadence_position field + // Units: rpm + // Comment: Maximum cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxCadencePosition(FIT_UINT8 index) const + { + return GetFieldUINT8Value(123, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_cadence_position field + // Units: rpm + // Comment: Maximum cadence by position. Data value indexes defined by rider_position_type. + /////////////////////////////////////////////////////////////////////// + void SetMaxCadencePosition(FIT_UINT8 index, FIT_UINT8 maxCadencePosition) + { + SetFieldUINT8Value(123, maxCadencePosition, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgSpeedValid() const + { + const Field* field = GetField(124); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_speed field + // Units: m/s + // Comment: total_distance / total_timer_time + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgSpeed(void) const + { + return GetFieldFLOAT32Value(124, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_speed field + // Units: m/s + // Comment: total_distance / total_timer_time + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgSpeed(FIT_FLOAT32 enhancedAvgSpeed) + { + SetFieldFLOAT32Value(124, enhancedAvgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxSpeedValid() const + { + const Field* field = GetField(125); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxSpeed(void) const + { + return GetFieldFLOAT32Value(125, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxSpeed(FIT_FLOAT32 enhancedMaxSpeed) + { + SetFieldFLOAT32Value(125, enhancedMaxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgAltitudeValid() const + { + const Field* field = GetField(126); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgAltitude(void) const + { + return GetFieldFLOAT32Value(126, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgAltitude(FIT_FLOAT32 enhancedAvgAltitude) + { + SetFieldFLOAT32Value(126, enhancedAvgAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_min_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMinAltitudeValid() const + { + const Field* field = GetField(127); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMinAltitude(void) const + { + return GetFieldFLOAT32Value(127, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_min_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMinAltitude(FIT_FLOAT32 enhancedMinAltitude) + { + SetFieldFLOAT32Value(127, enhancedMinAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_altitude field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxAltitudeValid() const + { + const Field* field = GetField(128); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxAltitude(void) const + { + return GetFieldFLOAT32Value(128, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_altitude field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxAltitude(FIT_FLOAT32 enhancedMaxAltitude) + { + SetFieldFLOAT32Value(128, enhancedMaxAltitude, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_lev_motor_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgLevMotorPowerValid() const + { + const Field* field = GetField(129); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_lev_motor_power field + // Units: watts + // Comment: lev average motor power during session + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetAvgLevMotorPower(void) const + { + return GetFieldUINT16Value(129, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_lev_motor_power field + // Units: watts + // Comment: lev average motor power during session + /////////////////////////////////////////////////////////////////////// + void SetAvgLevMotorPower(FIT_UINT16 avgLevMotorPower) + { + SetFieldUINT16Value(129, avgLevMotorPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_lev_motor_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxLevMotorPowerValid() const + { + const Field* field = GetField(130); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_lev_motor_power field + // Units: watts + // Comment: lev maximum motor power during session + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMaxLevMotorPower(void) const + { + return GetFieldUINT16Value(130, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_lev_motor_power field + // Units: watts + // Comment: lev maximum motor power during session + /////////////////////////////////////////////////////////////////////// + void SetMaxLevMotorPower(FIT_UINT16 maxLevMotorPower) + { + SetFieldUINT16Value(130, maxLevMotorPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of lev_battery_consumption field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLevBatteryConsumptionValid() const + { + const Field* field = GetField(131); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns lev_battery_consumption field + // Units: percent + // Comment: lev battery consumption during session + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetLevBatteryConsumption(void) const + { + return GetFieldFLOAT32Value(131, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set lev_battery_consumption field + // Units: percent + // Comment: lev battery consumption during session + /////////////////////////////////////////////////////////////////////// + void SetLevBatteryConsumption(FIT_FLOAT32 levBatteryConsumption) + { + SetFieldFLOAT32Value(131, levBatteryConsumption, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vertical_ratio field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVerticalRatioValid() const + { + const Field* field = GetField(132); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vertical_ratio field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVerticalRatio(void) const + { + return GetFieldFLOAT32Value(132, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vertical_ratio field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgVerticalRatio(FIT_FLOAT32 avgVerticalRatio) + { + SetFieldFLOAT32Value(132, avgVerticalRatio, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stance_time_balance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStanceTimeBalanceValid() const + { + const Field* field = GetField(133); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stance_time_balance field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStanceTimeBalance(void) const + { + return GetFieldFLOAT32Value(133, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stance_time_balance field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetAvgStanceTimeBalance(FIT_FLOAT32 avgStanceTimeBalance) + { + SetFieldFLOAT32Value(133, avgStanceTimeBalance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_step_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStepLengthValid() const + { + const Field* field = GetField(134); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_step_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgStepLength(void) const + { + return GetFieldFLOAT32Value(134, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_step_length field + // Units: mm + /////////////////////////////////////////////////////////////////////// + void SetAvgStepLength(FIT_FLOAT32 avgStepLength) + { + SetFieldFLOAT32Value(134, avgStepLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_anaerobic_training_effect field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalAnaerobicTrainingEffectValid() const + { + const Field* field = GetField(137); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_anaerobic_training_effect field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalAnaerobicTrainingEffect(void) const + { + return GetFieldFLOAT32Value(137, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_anaerobic_training_effect field + /////////////////////////////////////////////////////////////////////// + void SetTotalAnaerobicTrainingEffect(FIT_FLOAT32 totalAnaerobicTrainingEffect) + { + SetFieldFLOAT32Value(137, totalAnaerobicTrainingEffect, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vam field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVamValid() const + { + const Field* field = GetField(139); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vam field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVam(void) const + { + return GetFieldFLOAT32Value(139, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vam field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgVam(FIT_FLOAT32 avgVam) + { + SetFieldFLOAT32Value(139, avgVam, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgDepthValid() const + { + const Field* field = GetField(140); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgDepth(void) const + { + return GetFieldFLOAT32Value(140, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetAvgDepth(FIT_FLOAT32 avgDepth) + { + SetFieldFLOAT32Value(140, avgDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_depth field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxDepthValid() const + { + const Field* field = GetField(141); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxDepth(void) const + { + return GetFieldFLOAT32Value(141, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_depth field + // Units: m + // Comment: 0 if above water + /////////////////////////////////////////////////////////////////////// + void SetMaxDepth(FIT_FLOAT32 maxDepth) + { + SetFieldFLOAT32Value(141, maxDepth, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of surface_interval field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSurfaceIntervalValid() const + { + const Field* field = GetField(142); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns surface_interval field + // Units: s + // Comment: Time since end of last dive + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSurfaceInterval(void) const + { + return GetFieldUINT32Value(142, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set surface_interval field + // Units: s + // Comment: Time since end of last dive + /////////////////////////////////////////////////////////////////////// + void SetSurfaceInterval(FIT_UINT32 surfaceInterval) + { + SetFieldUINT32Value(142, surfaceInterval, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_cns field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartCnsValid() const + { + const Field* field = GetField(143); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetStartCns(void) const + { + return GetFieldUINT8Value(143, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetStartCns(FIT_UINT8 startCns) + { + SetFieldUINT8Value(143, startCns, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_cns field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndCnsValid() const + { + const Field* field = GetField(144); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetEndCns(void) const + { + return GetFieldUINT8Value(144, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_cns field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetEndCns(FIT_UINT8 endCns) + { + SetFieldUINT8Value(144, endCns, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_n2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartN2Valid() const + { + const Field* field = GetField(145); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStartN2(void) const + { + return GetFieldUINT16Value(145, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetStartN2(FIT_UINT16 startN2) + { + SetFieldUINT16Value(145, startN2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_n2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndN2Valid() const + { + const Field* field = GetField(146); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetEndN2(void) const + { + return GetFieldUINT16Value(146, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_n2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetEndN2(FIT_UINT16 endN2) + { + SetFieldUINT16Value(146, endN2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgRespirationRateValid() const + { + const Field* field = GetField(147); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgRespirationRate(void) const + { + return GetFieldUINT8Value(147, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetAvgRespirationRate(FIT_UINT8 avgRespirationRate) + { + SetFieldUINT8Value(147, avgRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxRespirationRateValid() const + { + const Field* field = GetField(148); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxRespirationRate(void) const + { + return GetFieldUINT8Value(148, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetMaxRespirationRate(FIT_UINT8 maxRespirationRate) + { + SetFieldUINT8Value(148, maxRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinRespirationRateValid() const + { + const Field* field = GetField(149); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMinRespirationRate(void) const + { + return GetFieldUINT8Value(149, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetMinRespirationRate(FIT_UINT8 minRespirationRate) + { + SetFieldUINT8Value(149, minRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinTemperatureValid() const + { + const Field* field = GetField(150); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetMinTemperature(void) const + { + return GetFieldSINT8Value(150, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMinTemperature(FIT_SINT8 minTemperature) + { + SetFieldSINT8Value(150, minTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of o2_toxicity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsO2ToxicityValid() const + { + const Field* field = GetField(155); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns o2_toxicity field + // Units: OTUs + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetO2Toxicity(void) const + { + return GetFieldUINT16Value(155, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set o2_toxicity field + // Units: OTUs + /////////////////////////////////////////////////////////////////////// + void SetO2Toxicity(FIT_UINT16 o2Toxicity) + { + SetFieldUINT16Value(155, o2Toxicity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveNumberValid() const + { + const Field* field = GetField(156); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dive_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDiveNumber(void) const + { + return GetFieldUINT32Value(156, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_number field + /////////////////////////////////////////////////////////////////////// + void SetDiveNumber(FIT_UINT32 diveNumber) + { + SetFieldUINT32Value(156, diveNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of training_load_peak field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTrainingLoadPeakValid() const + { + const Field* field = GetField(168); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns training_load_peak field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTrainingLoadPeak(void) const + { + return GetFieldFLOAT32Value(168, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set training_load_peak field + /////////////////////////////////////////////////////////////////////// + void SetTrainingLoadPeak(FIT_FLOAT32 trainingLoadPeak) + { + SetFieldFLOAT32Value(168, trainingLoadPeak, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_avg_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedAvgRespirationRateValid() const + { + const Field* field = GetField(169); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_avg_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedAvgRespirationRate(void) const + { + return GetFieldFLOAT32Value(169, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_avg_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedAvgRespirationRate(FIT_FLOAT32 enhancedAvgRespirationRate) + { + SetFieldFLOAT32Value(169, enhancedAvgRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_max_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMaxRespirationRateValid() const + { + const Field* field = GetField(170); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_max_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMaxRespirationRate(void) const + { + return GetFieldFLOAT32Value(170, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_max_respiration_rate field + // Units: Breaths/min + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMaxRespirationRate(FIT_FLOAT32 enhancedMaxRespirationRate) + { + SetFieldFLOAT32Value(170, enhancedMaxRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of enhanced_min_respiration_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEnhancedMinRespirationRateValid() const + { + const Field* field = GetField(180); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns enhanced_min_respiration_rate field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEnhancedMinRespirationRate(void) const + { + return GetFieldFLOAT32Value(180, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set enhanced_min_respiration_rate field + /////////////////////////////////////////////////////////////////////// + void SetEnhancedMinRespirationRate(FIT_FLOAT32 enhancedMinRespirationRate) + { + SetFieldFLOAT32Value(180, enhancedMinRespirationRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalGritValid() const + { + const Field* field = GetField(181); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalGrit(void) const + { + return GetFieldFLOAT32Value(181, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetTotalGrit(FIT_FLOAT32 totalGrit) + { + SetFieldFLOAT32Value(181, totalGrit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFlowValid() const + { + const Field* field = GetField(182); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFlow(void) const + { + return GetFieldFLOAT32Value(182, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetTotalFlow(FIT_FLOAT32 totalFlow) + { + SetFieldFLOAT32Value(182, totalFlow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of jump_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsJumpCountValid() const + { + const Field* field = GetField(183); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns jump_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetJumpCount(void) const + { + return GetFieldUINT16Value(183, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set jump_count field + /////////////////////////////////////////////////////////////////////// + void SetJumpCount(FIT_UINT16 jumpCount) + { + SetFieldUINT16Value(183, jumpCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_grit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgGritValid() const + { + const Field* field = GetField(186); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgGrit(void) const + { + return GetFieldFLOAT32Value(186, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_grit field + // Units: kGrit + // Comment: The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes. + /////////////////////////////////////////////////////////////////////// + void SetAvgGrit(FIT_FLOAT32 avgGrit) + { + SetFieldFLOAT32Value(186, avgGrit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_flow field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgFlowValid() const + { + const Field* field = GetField(187); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgFlow(void) const + { + return GetFieldFLOAT32Value(187, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_flow field + // Units: Flow + // Comment: The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals. + /////////////////////////////////////////////////////////////////////// + void SetAvgFlow(FIT_FLOAT32 avgFlow) + { + SetFieldFLOAT32Value(187, avgFlow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of workout_feel field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWorkoutFeelValid() const + { + const Field* field = GetField(192); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns workout_feel field + // Comment: A 0-100 scale representing how a user felt while performing a workout. Low values are considered feeling bad, while high values are good. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetWorkoutFeel(void) const + { + return GetFieldUINT8Value(192, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set workout_feel field + // Comment: A 0-100 scale representing how a user felt while performing a workout. Low values are considered feeling bad, while high values are good. + /////////////////////////////////////////////////////////////////////// + void SetWorkoutFeel(FIT_UINT8 workoutFeel) + { + SetFieldUINT8Value(192, workoutFeel, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of workout_rpe field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWorkoutRpeValid() const + { + const Field* field = GetField(193); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns workout_rpe field + // Comment: Common Borg CR10 / 0-10 RPE scale, multiplied 10x.. Aggregate score for all workouts in a single session. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetWorkoutRpe(void) const + { + return GetFieldUINT8Value(193, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set workout_rpe field + // Comment: Common Borg CR10 / 0-10 RPE scale, multiplied 10x.. Aggregate score for all workouts in a single session. + /////////////////////////////////////////////////////////////////////// + void SetWorkoutRpe(FIT_UINT8 workoutRpe) + { + SetFieldUINT8Value(193, workoutRpe, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_spo2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpo2Valid() const + { + const Field* field = GetField(194); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_spo2 field + // Units: percent + // Comment: Average SPO2 for the monitoring session + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgSpo2(void) const + { + return GetFieldUINT8Value(194, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_spo2 field + // Units: percent + // Comment: Average SPO2 for the monitoring session + /////////////////////////////////////////////////////////////////////// + void SetAvgSpo2(FIT_UINT8 avgSpo2) + { + SetFieldUINT8Value(194, avgSpo2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_stress field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgStressValid() const + { + const Field* field = GetField(195); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_stress field + // Units: percent + // Comment: Average stress for the monitoring session + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgStress(void) const + { + return GetFieldUINT8Value(195, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_stress field + // Units: percent + // Comment: Average stress for the monitoring session + /////////////////////////////////////////////////////////////////////// + void SetAvgStress(FIT_UINT8 avgStress) + { + SetFieldUINT8Value(195, avgStress, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sdrr_hrv field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSdrrHrvValid() const + { + const Field* field = GetField(197); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sdrr_hrv field + // Units: mS + // Comment: Standard deviation of R-R interval (SDRR) - Heart rate variability measure most useful for wellness users. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSdrrHrv(void) const + { + return GetFieldUINT8Value(197, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sdrr_hrv field + // Units: mS + // Comment: Standard deviation of R-R interval (SDRR) - Heart rate variability measure most useful for wellness users. + /////////////////////////////////////////////////////////////////////// + void SetSdrrHrv(FIT_UINT8 sdrrHrv) + { + SetFieldUINT8Value(197, sdrrHrv, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rmssd_hrv field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRmssdHrvValid() const + { + const Field* field = GetField(198); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rmssd_hrv field + // Units: mS + // Comment: Root mean square successive difference (RMSSD) - Heart rate variability measure most useful for athletes + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRmssdHrv(void) const + { + return GetFieldUINT8Value(198, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rmssd_hrv field + // Units: mS + // Comment: Root mean square successive difference (RMSSD) - Heart rate variability measure most useful for athletes + /////////////////////////////////////////////////////////////////////// + void SetRmssdHrv(FIT_UINT8 rmssdHrv) + { + SetFieldUINT8Value(198, rmssdHrv, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalAscentValid() const + { + const Field* field = GetField(199); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_ascent field + // Units: m + // Comment: fractional part of total_ascent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalAscent(void) const + { + return GetFieldFLOAT32Value(199, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_ascent field + // Units: m + // Comment: fractional part of total_ascent + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalAscent(FIT_FLOAT32 totalFractionalAscent) + { + SetFieldFLOAT32Value(199, totalFractionalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_fractional_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalFractionalDescentValid() const + { + const Field* field = GetField(200); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_fractional_descent field + // Units: m + // Comment: fractional part of total_descent + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalFractionalDescent(void) const + { + return GetFieldFLOAT32Value(200, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_fractional_descent field + // Units: m + // Comment: fractional part of total_descent + /////////////////////////////////////////////////////////////////////// + void SetTotalFractionalDescent(FIT_FLOAT32 totalFractionalDescent) + { + SetFieldFLOAT32Value(200, totalFractionalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgCoreTemperatureValid() const + { + const Field* field = GetField(208); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgCoreTemperature(void) const + { + return GetFieldFLOAT32Value(208, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetAvgCoreTemperature(FIT_FLOAT32 avgCoreTemperature) + { + SetFieldFLOAT32Value(208, avgCoreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of min_core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMinCoreTemperatureValid() const + { + const Field* field = GetField(209); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns min_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMinCoreTemperature(void) const + { + return GetFieldFLOAT32Value(209, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set min_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMinCoreTemperature(FIT_FLOAT32 minCoreTemperature) + { + SetFieldFLOAT32Value(209, minCoreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_core_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxCoreTemperatureValid() const + { + const Field* field = GetField(210); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxCoreTemperature(void) const + { + return GetFieldFLOAT32Value(210, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_core_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetMaxCoreTemperature(FIT_FLOAT32 maxCoreTemperature) + { + SetFieldFLOAT32Value(210, maxCoreTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SESSION_MESG_HPP) diff --git a/fit_session_mesg_listener.hpp b/fit_session_mesg_listener.hpp new file mode 100644 index 0000000..dc89c1c --- /dev/null +++ b/fit_session_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SESSION_MESG_LISTENER_HPP) +#define FIT_SESSION_MESG_LISTENER_HPP + +#include "fit_session_mesg.hpp" + +namespace fit +{ + +class SessionMesgListener +{ +public: + virtual ~SessionMesgListener() {} + virtual void OnMesg(SessionMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SESSION_MESG_LISTENER_HPP) diff --git a/fit_set_mesg.hpp b/fit_set_mesg.hpp new file mode 100644 index 0000000..b3a24dc --- /dev/null +++ b/fit_set_mesg.hpp @@ -0,0 +1,424 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SET_MESG_HPP) +#define FIT_SET_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SetMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 254; + static const FIT_UINT8 Duration = 0; + static const FIT_UINT8 Repetitions = 3; + static const FIT_UINT8 Weight = 4; + static const FIT_UINT8 SetType = 5; + static const FIT_UINT8 StartTime = 6; + static const FIT_UINT8 Category = 7; + static const FIT_UINT8 CategorySubtype = 8; + static const FIT_UINT8 WeightDisplayUnit = 9; + static const FIT_UINT8 MessageIndex = 10; + static const FIT_UINT8 WktStepIndex = 11; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SetMesg(void) : Mesg(Profile::MESG_SET) + { + } + + SetMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Comment: Timestamp of the set + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Comment: Timestamp of the set + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(254, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns duration field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDuration(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetDuration(FIT_FLOAT32 duration) + { + SetFieldFLOAT32Value(0, duration, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repetitions field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepetitionsValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns repetitions field + // Comment: # of repitions of the movement + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetRepetitions(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set repetitions field + // Comment: # of repitions of the movement + /////////////////////////////////////////////////////////////////////// + void SetRepetitions(FIT_UINT16 repetitions) + { + SetFieldUINT16Value(3, repetitions, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weight field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeightValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weight field + // Units: kg + // Comment: Amount of weight applied for the set + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetWeight(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weight field + // Units: kg + // Comment: Amount of weight applied for the set + /////////////////////////////////////////////////////////////////////// + void SetWeight(FIT_FLOAT32 weight) + { + SetFieldFLOAT32Value(4, weight, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of set_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSetTypeValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns set_type field + /////////////////////////////////////////////////////////////////////// + FIT_SET_TYPE GetSetType(void) const + { + return GetFieldUINT8Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set set_type field + /////////////////////////////////////////////////////////////////////// + void SetSetType(FIT_SET_TYPE setType) + { + SetFieldUINT8Value(5, setType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimeValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_time field + // Comment: Start time of the set + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTime(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_time field + // Comment: Start time of the set + /////////////////////////////////////////////////////////////////////// + void SetStartTime(FIT_DATE_TIME startTime) + { + SetFieldUINT32Value(6, startTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of category + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCategory(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of category field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCategoryValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns category field + /////////////////////////////////////////////////////////////////////// + FIT_EXERCISE_CATEGORY GetCategory(FIT_UINT8 index) const + { + return GetFieldUINT16Value(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set category field + /////////////////////////////////////////////////////////////////////// + void SetCategory(FIT_UINT8 index, FIT_EXERCISE_CATEGORY category) + { + SetFieldUINT16Value(7, category, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of category_subtype + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCategorySubtype(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of category_subtype field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCategorySubtypeValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns category_subtype field + // Comment: Based on the associated category, see [category]_exercise_names + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetCategorySubtype(FIT_UINT8 index) const + { + return GetFieldUINT16Value(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set category_subtype field + // Comment: Based on the associated category, see [category]_exercise_names + /////////////////////////////////////////////////////////////////////// + void SetCategorySubtype(FIT_UINT8 index, FIT_UINT16 categorySubtype) + { + SetFieldUINT16Value(8, categorySubtype, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weight_display_unit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeightDisplayUnitValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weight_display_unit field + /////////////////////////////////////////////////////////////////////// + FIT_FIT_BASE_UNIT GetWeightDisplayUnit(void) const + { + return GetFieldUINT16Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weight_display_unit field + /////////////////////////////////////////////////////////////////////// + void SetWeightDisplayUnit(FIT_FIT_BASE_UNIT weightDisplayUnit) + { + SetFieldUINT16Value(9, weightDisplayUnit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(10, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_step_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktStepIndexValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_step_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetWktStepIndex(void) const + { + return GetFieldUINT16Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_step_index field + /////////////////////////////////////////////////////////////////////// + void SetWktStepIndex(FIT_MESSAGE_INDEX wktStepIndex) + { + SetFieldUINT16Value(11, wktStepIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SET_MESG_HPP) diff --git a/fit_set_mesg_listener.hpp b/fit_set_mesg_listener.hpp new file mode 100644 index 0000000..9ffed0f --- /dev/null +++ b/fit_set_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SET_MESG_LISTENER_HPP) +#define FIT_SET_MESG_LISTENER_HPP + +#include "fit_set_mesg.hpp" + +namespace fit +{ + +class SetMesgListener +{ +public: + virtual ~SetMesgListener() {} + virtual void OnMesg(SetMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SET_MESG_LISTENER_HPP) diff --git a/fit_skin_temp_overnight_mesg.hpp b/fit_skin_temp_overnight_mesg.hpp new file mode 100644 index 0000000..0a1e4e5 --- /dev/null +++ b/fit_skin_temp_overnight_mesg.hpp @@ -0,0 +1,208 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SKIN_TEMP_OVERNIGHT_MESG_HPP) +#define FIT_SKIN_TEMP_OVERNIGHT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SkinTempOvernightMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 LocalTimestamp = 0; + static const FIT_UINT8 AverageDeviation = 1; + static const FIT_UINT8 Average7DayDeviation = 2; + static const FIT_UINT8 NightlyValue = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SkinTempOvernightMesg(void) : Mesg(Profile::MESG_SKIN_TEMP_OVERNIGHT) + { + } + + SkinTempOvernightMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalTimestampValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns local_timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DATE_TIME GetLocalTimestamp(void) const + { + return GetFieldUINT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_timestamp field + /////////////////////////////////////////////////////////////////////// + void SetLocalTimestamp(FIT_LOCAL_DATE_TIME localTimestamp) + { + SetFieldUINT32Value(0, localTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of average_deviation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAverageDeviationValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns average_deviation field + // Comment: The average overnight deviation from baseline temperature in degrees C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAverageDeviation(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set average_deviation field + // Comment: The average overnight deviation from baseline temperature in degrees C + /////////////////////////////////////////////////////////////////////// + void SetAverageDeviation(FIT_FLOAT32 averageDeviation) + { + SetFieldFLOAT32Value(1, averageDeviation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of average_7_day_deviation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAverage7DayDeviationValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns average_7_day_deviation field + // Comment: The average 7 day overnight deviation from baseline temperature in degrees C + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAverage7DayDeviation(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set average_7_day_deviation field + // Comment: The average 7 day overnight deviation from baseline temperature in degrees C + /////////////////////////////////////////////////////////////////////// + void SetAverage7DayDeviation(FIT_FLOAT32 average7DayDeviation) + { + SetFieldFLOAT32Value(2, average7DayDeviation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of nightly_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNightlyValueValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns nightly_value field + // Comment: Final overnight temperature value + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetNightlyValue(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set nightly_value field + // Comment: Final overnight temperature value + /////////////////////////////////////////////////////////////////////// + void SetNightlyValue(FIT_FLOAT32 nightlyValue) + { + SetFieldFLOAT32Value(4, nightlyValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SKIN_TEMP_OVERNIGHT_MESG_HPP) diff --git a/fit_skin_temp_overnight_mesg_listener.hpp b/fit_skin_temp_overnight_mesg_listener.hpp new file mode 100644 index 0000000..5b9358b --- /dev/null +++ b/fit_skin_temp_overnight_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SKIN_TEMP_OVERNIGHT_MESG_LISTENER_HPP) +#define FIT_SKIN_TEMP_OVERNIGHT_MESG_LISTENER_HPP + +#include "fit_skin_temp_overnight_mesg.hpp" + +namespace fit +{ + +class SkinTempOvernightMesgListener +{ +public: + virtual ~SkinTempOvernightMesgListener() {} + virtual void OnMesg(SkinTempOvernightMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SKIN_TEMP_OVERNIGHT_MESG_LISTENER_HPP) diff --git a/fit_slave_device_mesg.hpp b/fit_slave_device_mesg.hpp new file mode 100644 index 0000000..85fca53 --- /dev/null +++ b/fit_slave_device_mesg.hpp @@ -0,0 +1,180 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLAVE_DEVICE_MESG_HPP) +#define FIT_SLAVE_DEVICE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SlaveDeviceMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Manufacturer = 0; + static const FIT_UINT8 Product = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SlaveDeviceMesg(void) : Mesg(Profile::MESG_SLAVE_DEVICE) + { + } + + SlaveDeviceMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer field + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturer(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer field + /////////////////////////////////////////////////////////////////////// + void SetManufacturer(FIT_MANUFACTURER manufacturer) + { + SetFieldUINT16Value(0, manufacturer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProduct(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product field + /////////////////////////////////////////////////////////////////////// + void SetProduct(FIT_UINT16 product) + { + SetFieldUINT16Value(1, product, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of favero_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFaveroProductValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns favero_product field + /////////////////////////////////////////////////////////////////////// + FIT_FAVERO_PRODUCT GetFaveroProduct(void) const + { + return GetFieldUINT16Value(1, 0, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set favero_product field + /////////////////////////////////////////////////////////////////////// + void SetFaveroProduct(FIT_FAVERO_PRODUCT faveroProduct) + { + SetFieldUINT16Value(1, faveroProduct, 0, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of garmin_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGarminProductValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns garmin_product field + /////////////////////////////////////////////////////////////////////// + FIT_GARMIN_PRODUCT GetGarminProduct(void) const + { + return GetFieldUINT16Value(1, 0, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set garmin_product field + /////////////////////////////////////////////////////////////////////// + void SetGarminProduct(FIT_GARMIN_PRODUCT garminProduct) + { + SetFieldUINT16Value(1, garminProduct, 0, (FIT_UINT16) Profile::SLAVE_DEVICE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SLAVE_DEVICE_MESG_HPP) diff --git a/fit_slave_device_mesg_listener.hpp b/fit_slave_device_mesg_listener.hpp new file mode 100644 index 0000000..464647d --- /dev/null +++ b/fit_slave_device_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLAVE_DEVICE_MESG_LISTENER_HPP) +#define FIT_SLAVE_DEVICE_MESG_LISTENER_HPP + +#include "fit_slave_device_mesg.hpp" + +namespace fit +{ + +class SlaveDeviceMesgListener +{ +public: + virtual ~SlaveDeviceMesgListener() {} + virtual void OnMesg(SlaveDeviceMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SLAVE_DEVICE_MESG_LISTENER_HPP) diff --git a/fit_sleep_assessment_mesg.hpp b/fit_sleep_assessment_mesg.hpp new file mode 100644 index 0000000..240fa5d --- /dev/null +++ b/fit_sleep_assessment_mesg.hpp @@ -0,0 +1,518 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_ASSESSMENT_MESG_HPP) +#define FIT_SLEEP_ASSESSMENT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SleepAssessmentMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 CombinedAwakeScore = 0; + static const FIT_UINT8 AwakeTimeScore = 1; + static const FIT_UINT8 AwakeningsCountScore = 2; + static const FIT_UINT8 DeepSleepScore = 3; + static const FIT_UINT8 SleepDurationScore = 4; + static const FIT_UINT8 LightSleepScore = 5; + static const FIT_UINT8 OverallSleepScore = 6; + static const FIT_UINT8 SleepQualityScore = 7; + static const FIT_UINT8 SleepRecoveryScore = 8; + static const FIT_UINT8 RemSleepScore = 9; + static const FIT_UINT8 SleepRestlessnessScore = 10; + static const FIT_UINT8 AwakeningsCount = 11; + static const FIT_UINT8 InterruptionsScore = 14; + static const FIT_UINT8 AverageStressDuringSleep = 15; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SleepAssessmentMesg(void) : Mesg(Profile::MESG_SLEEP_ASSESSMENT) + { + } + + SleepAssessmentMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of combined_awake_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCombinedAwakeScoreValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns combined_awake_score field + // Comment: Average of awake_time_score and awakenings_count_score. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetCombinedAwakeScore(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set combined_awake_score field + // Comment: Average of awake_time_score and awakenings_count_score. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetCombinedAwakeScore(FIT_UINT8 combinedAwakeScore) + { + SetFieldUINT8Value(0, combinedAwakeScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of awake_time_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAwakeTimeScoreValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns awake_time_score field + // Comment: Score that evaluates the total time spent awake between sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAwakeTimeScore(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set awake_time_score field + // Comment: Score that evaluates the total time spent awake between sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetAwakeTimeScore(FIT_UINT8 awakeTimeScore) + { + SetFieldUINT8Value(1, awakeTimeScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of awakenings_count_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAwakeningsCountScoreValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns awakenings_count_score field + // Comment: Score that evaluates the number of awakenings that interrupt sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAwakeningsCountScore(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set awakenings_count_score field + // Comment: Score that evaluates the number of awakenings that interrupt sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetAwakeningsCountScore(FIT_UINT8 awakeningsCountScore) + { + SetFieldUINT8Value(2, awakeningsCountScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of deep_sleep_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDeepSleepScoreValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns deep_sleep_score field + // Comment: Score that evaluates the amount of deep sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDeepSleepScore(void) const + { + return GetFieldUINT8Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set deep_sleep_score field + // Comment: Score that evaluates the amount of deep sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetDeepSleepScore(FIT_UINT8 deepSleepScore) + { + SetFieldUINT8Value(3, deepSleepScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sleep_duration_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSleepDurationScoreValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sleep_duration_score field + // Comment: Score that evaluates the quality of sleep based on sleep stages, heart-rate variability and possible awakenings during the night. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSleepDurationScore(void) const + { + return GetFieldUINT8Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sleep_duration_score field + // Comment: Score that evaluates the quality of sleep based on sleep stages, heart-rate variability and possible awakenings during the night. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetSleepDurationScore(FIT_UINT8 sleepDurationScore) + { + SetFieldUINT8Value(4, sleepDurationScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of light_sleep_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLightSleepScoreValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns light_sleep_score field + // Comment: Score that evaluates the amount of light sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetLightSleepScore(void) const + { + return GetFieldUINT8Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set light_sleep_score field + // Comment: Score that evaluates the amount of light sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetLightSleepScore(FIT_UINT8 lightSleepScore) + { + SetFieldUINT8Value(5, lightSleepScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of overall_sleep_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOverallSleepScoreValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns overall_sleep_score field + // Comment: Total score that summarizes the overall quality of sleep, combining sleep duration and quality. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetOverallSleepScore(void) const + { + return GetFieldUINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set overall_sleep_score field + // Comment: Total score that summarizes the overall quality of sleep, combining sleep duration and quality. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetOverallSleepScore(FIT_UINT8 overallSleepScore) + { + SetFieldUINT8Value(6, overallSleepScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sleep_quality_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSleepQualityScoreValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sleep_quality_score field + // Comment: Score that evaluates the quality of sleep based on sleep stages, heart-rate variability and possible awakenings during the night. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSleepQualityScore(void) const + { + return GetFieldUINT8Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sleep_quality_score field + // Comment: Score that evaluates the quality of sleep based on sleep stages, heart-rate variability and possible awakenings during the night. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetSleepQualityScore(FIT_UINT8 sleepQualityScore) + { + SetFieldUINT8Value(7, sleepQualityScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sleep_recovery_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSleepRecoveryScoreValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sleep_recovery_score field + // Comment: Score that evaluates stress and recovery during sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSleepRecoveryScore(void) const + { + return GetFieldUINT8Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sleep_recovery_score field + // Comment: Score that evaluates stress and recovery during sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetSleepRecoveryScore(FIT_UINT8 sleepRecoveryScore) + { + SetFieldUINT8Value(8, sleepRecoveryScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of rem_sleep_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRemSleepScoreValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns rem_sleep_score field + // Comment: Score that evaluates the amount of REM sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRemSleepScore(void) const + { + return GetFieldUINT8Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set rem_sleep_score field + // Comment: Score that evaluates the amount of REM sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetRemSleepScore(FIT_UINT8 remSleepScore) + { + SetFieldUINT8Value(9, remSleepScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sleep_restlessness_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSleepRestlessnessScoreValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sleep_restlessness_score field + // Comment: Score that evaluates the amount of restlessness during sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSleepRestlessnessScore(void) const + { + return GetFieldUINT8Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sleep_restlessness_score field + // Comment: Score that evaluates the amount of restlessness during sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetSleepRestlessnessScore(FIT_UINT8 sleepRestlessnessScore) + { + SetFieldUINT8Value(10, sleepRestlessnessScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of awakenings_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAwakeningsCountValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns awakenings_count field + // Comment: The number of awakenings during sleep. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAwakeningsCount(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set awakenings_count field + // Comment: The number of awakenings during sleep. + /////////////////////////////////////////////////////////////////////// + void SetAwakeningsCount(FIT_UINT8 awakeningsCount) + { + SetFieldUINT8Value(11, awakeningsCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of interruptions_score field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsInterruptionsScoreValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns interruptions_score field + // Comment: Score that evaluates the sleep interruptions. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetInterruptionsScore(void) const + { + return GetFieldUINT8Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set interruptions_score field + // Comment: Score that evaluates the sleep interruptions. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID. + /////////////////////////////////////////////////////////////////////// + void SetInterruptionsScore(FIT_UINT8 interruptionsScore) + { + SetFieldUINT8Value(14, interruptionsScore, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of average_stress_during_sleep field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAverageStressDuringSleepValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns average_stress_during_sleep field + // Comment: Excludes stress during awake periods in the sleep window + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAverageStressDuringSleep(void) const + { + return GetFieldFLOAT32Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set average_stress_during_sleep field + // Comment: Excludes stress during awake periods in the sleep window + /////////////////////////////////////////////////////////////////////// + void SetAverageStressDuringSleep(FIT_FLOAT32 averageStressDuringSleep) + { + SetFieldFLOAT32Value(15, averageStressDuringSleep, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_ASSESSMENT_MESG_HPP) diff --git a/fit_sleep_assessment_mesg_listener.hpp b/fit_sleep_assessment_mesg_listener.hpp new file mode 100644 index 0000000..dfc4ab9 --- /dev/null +++ b/fit_sleep_assessment_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_ASSESSMENT_MESG_LISTENER_HPP) +#define FIT_SLEEP_ASSESSMENT_MESG_LISTENER_HPP + +#include "fit_sleep_assessment_mesg.hpp" + +namespace fit +{ + +class SleepAssessmentMesgListener +{ +public: + virtual ~SleepAssessmentMesgListener() {} + virtual void OnMesg(SleepAssessmentMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_ASSESSMENT_MESG_LISTENER_HPP) diff --git a/fit_sleep_disruption_overnight_severity_mesg.hpp b/fit_sleep_disruption_overnight_severity_mesg.hpp new file mode 100644 index 0000000..312e464 --- /dev/null +++ b/fit_sleep_disruption_overnight_severity_mesg.hpp @@ -0,0 +1,106 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_HPP) +#define FIT_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SleepDisruptionOvernightSeverityMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Severity = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SleepDisruptionOvernightSeverityMesg(void) : Mesg(Profile::MESG_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY) + { + } + + SleepDisruptionOvernightSeverityMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of severity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSeverityValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns severity field + /////////////////////////////////////////////////////////////////////// + FIT_SLEEP_DISRUPTION_SEVERITY GetSeverity(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set severity field + /////////////////////////////////////////////////////////////////////// + void SetSeverity(FIT_SLEEP_DISRUPTION_SEVERITY severity) + { + SetFieldENUMValue(0, severity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_HPP) diff --git a/fit_sleep_disruption_overnight_severity_mesg_listener.hpp b/fit_sleep_disruption_overnight_severity_mesg_listener.hpp new file mode 100644 index 0000000..6d426ae --- /dev/null +++ b/fit_sleep_disruption_overnight_severity_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_LISTENER_HPP) +#define FIT_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_LISTENER_HPP + +#include "fit_sleep_disruption_overnight_severity_mesg.hpp" + +namespace fit +{ + +class SleepDisruptionOvernightSeverityMesgListener +{ +public: + virtual ~SleepDisruptionOvernightSeverityMesgListener() {} + virtual void OnMesg(SleepDisruptionOvernightSeverityMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_DISRUPTION_OVERNIGHT_SEVERITY_MESG_LISTENER_HPP) diff --git a/fit_sleep_disruption_severity_period_mesg.hpp b/fit_sleep_disruption_severity_period_mesg.hpp new file mode 100644 index 0000000..a2f3541 --- /dev/null +++ b/fit_sleep_disruption_severity_period_mesg.hpp @@ -0,0 +1,138 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_HPP) +#define FIT_SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SleepDisruptionSeverityPeriodMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Severity = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SleepDisruptionSeverityPeriodMesg(void) : Mesg(Profile::MESG_SLEEP_DISRUPTION_SEVERITY_PERIOD) + { + } + + SleepDisruptionSeverityPeriodMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of severity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSeverityValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns severity field + /////////////////////////////////////////////////////////////////////// + FIT_SLEEP_DISRUPTION_SEVERITY GetSeverity(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set severity field + /////////////////////////////////////////////////////////////////////// + void SetSeverity(FIT_SLEEP_DISRUPTION_SEVERITY severity) + { + SetFieldENUMValue(0, severity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_HPP) diff --git a/fit_sleep_disruption_severity_period_mesg_listener.hpp b/fit_sleep_disruption_severity_period_mesg_listener.hpp new file mode 100644 index 0000000..5139136 --- /dev/null +++ b/fit_sleep_disruption_severity_period_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_LISTENER_HPP) +#define FIT_SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_LISTENER_HPP + +#include "fit_sleep_disruption_severity_period_mesg.hpp" + +namespace fit +{ + +class SleepDisruptionSeverityPeriodMesgListener +{ +public: + virtual ~SleepDisruptionSeverityPeriodMesgListener() {} + virtual void OnMesg(SleepDisruptionSeverityPeriodMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_DISRUPTION_SEVERITY_PERIOD_MESG_LISTENER_HPP) diff --git a/fit_sleep_level_mesg.hpp b/fit_sleep_level_mesg.hpp new file mode 100644 index 0000000..3c761c0 --- /dev/null +++ b/fit_sleep_level_mesg.hpp @@ -0,0 +1,108 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_LEVEL_MESG_HPP) +#define FIT_SLEEP_LEVEL_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SleepLevelMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 SleepLevel = 0; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SleepLevelMesg(void) : Mesg(Profile::MESG_SLEEP_LEVEL) + { + } + + SleepLevelMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sleep_level field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSleepLevelValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sleep_level field + /////////////////////////////////////////////////////////////////////// + FIT_SLEEP_LEVEL GetSleepLevel(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sleep_level field + /////////////////////////////////////////////////////////////////////// + void SetSleepLevel(FIT_SLEEP_LEVEL sleepLevel) + { + SetFieldENUMValue(0, sleepLevel, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_LEVEL_MESG_HPP) diff --git a/fit_sleep_level_mesg_listener.hpp b/fit_sleep_level_mesg_listener.hpp new file mode 100644 index 0000000..864989e --- /dev/null +++ b/fit_sleep_level_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SLEEP_LEVEL_MESG_LISTENER_HPP) +#define FIT_SLEEP_LEVEL_MESG_LISTENER_HPP + +#include "fit_sleep_level_mesg.hpp" + +namespace fit +{ + +class SleepLevelMesgListener +{ +public: + virtual ~SleepLevelMesgListener() {} + virtual void OnMesg(SleepLevelMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SLEEP_LEVEL_MESG_LISTENER_HPP) diff --git a/fit_software_mesg.hpp b/fit_software_mesg.hpp new file mode 100644 index 0000000..87345a1 --- /dev/null +++ b/fit_software_mesg.hpp @@ -0,0 +1,138 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SOFTWARE_MESG_HPP) +#define FIT_SOFTWARE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SoftwareMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Version = 3; + static const FIT_UINT8 PartNumber = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SoftwareMesg(void) : Mesg(Profile::MESG_SOFTWARE) + { + } + + SoftwareMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of version field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVersionValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns version field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVersion(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set version field + /////////////////////////////////////////////////////////////////////// + void SetVersion(FIT_FLOAT32 version) + { + SetFieldFLOAT32Value(3, version, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of part_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPartNumberValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns part_number field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetPartNumber(void) const + { + return GetFieldSTRINGValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set part_number field + /////////////////////////////////////////////////////////////////////// + void SetPartNumber(FIT_WSTRING partNumber) + { + SetFieldSTRINGValue(5, partNumber, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SOFTWARE_MESG_HPP) diff --git a/fit_software_mesg_listener.hpp b/fit_software_mesg_listener.hpp new file mode 100644 index 0000000..870c8cc --- /dev/null +++ b/fit_software_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SOFTWARE_MESG_LISTENER_HPP) +#define FIT_SOFTWARE_MESG_LISTENER_HPP + +#include "fit_software_mesg.hpp" + +namespace fit +{ + +class SoftwareMesgListener +{ +public: + virtual ~SoftwareMesgListener() {} + virtual void OnMesg(SoftwareMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SOFTWARE_MESG_LISTENER_HPP) diff --git a/fit_speed_zone_mesg.hpp b/fit_speed_zone_mesg.hpp new file mode 100644 index 0000000..8811e88 --- /dev/null +++ b/fit_speed_zone_mesg.hpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPEED_ZONE_MESG_HPP) +#define FIT_SPEED_ZONE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SpeedZoneMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 HighValue = 0; + static const FIT_UINT8 Name = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SpeedZoneMesg(void) : Mesg(Profile::MESG_SPEED_ZONE) + { + } + + SpeedZoneMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of high_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHighValueValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns high_value field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetHighValue(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set high_value field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetHighValue(FIT_FLOAT32 highValue) + { + SetFieldFLOAT32Value(0, highValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(1, name, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SPEED_ZONE_MESG_HPP) diff --git a/fit_speed_zone_mesg_listener.hpp b/fit_speed_zone_mesg_listener.hpp new file mode 100644 index 0000000..4f62ff9 --- /dev/null +++ b/fit_speed_zone_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPEED_ZONE_MESG_LISTENER_HPP) +#define FIT_SPEED_ZONE_MESG_LISTENER_HPP + +#include "fit_speed_zone_mesg.hpp" + +namespace fit +{ + +class SpeedZoneMesgListener +{ +public: + virtual ~SpeedZoneMesgListener() {} + virtual void OnMesg(SpeedZoneMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SPEED_ZONE_MESG_LISTENER_HPP) diff --git a/fit_split_mesg.hpp b/fit_split_mesg.hpp new file mode 100644 index 0000000..2c0da70 --- /dev/null +++ b/fit_split_mesg.hpp @@ -0,0 +1,680 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPLIT_MESG_HPP) +#define FIT_SPLIT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SplitMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 SplitType = 0; + static const FIT_UINT8 TotalElapsedTime = 1; + static const FIT_UINT8 TotalTimerTime = 2; + static const FIT_UINT8 TotalDistance = 3; + static const FIT_UINT8 AvgSpeed = 4; + static const FIT_UINT8 StartTime = 9; + static const FIT_UINT8 TotalAscent = 13; + static const FIT_UINT8 TotalDescent = 14; + static const FIT_UINT8 StartPositionLat = 21; + static const FIT_UINT8 StartPositionLong = 22; + static const FIT_UINT8 EndPositionLat = 23; + static const FIT_UINT8 EndPositionLong = 24; + static const FIT_UINT8 MaxSpeed = 25; + static const FIT_UINT8 AvgVertSpeed = 26; + static const FIT_UINT8 EndTime = 27; + static const FIT_UINT8 TotalCalories = 28; + static const FIT_UINT8 StartElevation = 74; + static const FIT_UINT8 TotalMovingTime = 110; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SplitMesg(void) : Mesg(Profile::MESG_SPLIT) + { + } + + SplitMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of split_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSplitTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns split_type field + /////////////////////////////////////////////////////////////////////// + FIT_SPLIT_TYPE GetSplitType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set split_type field + /////////////////////////////////////////////////////////////////////// + void SetSplitType(FIT_SPLIT_TYPE splitType) + { + SetFieldENUMValue(0, splitType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_elapsed_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalElapsedTimeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_elapsed_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalElapsedTime(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_elapsed_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalElapsedTime(FIT_FLOAT32 totalElapsedTime) + { + SetFieldFLOAT32Value(1, totalElapsedTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(2, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDistanceValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalDistance(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDistance(FIT_FLOAT32 totalDistance) + { + SetFieldFLOAT32Value(3, totalDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(4, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimeValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTime(void) const + { + return GetFieldUINT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_time field + /////////////////////////////////////////////////////////////////////// + void SetStartTime(FIT_DATE_TIME startTime) + { + SetFieldUINT32Value(9, startTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalAscentValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalAscent(void) const + { + return GetFieldUINT16Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalAscent(FIT_UINT16 totalAscent) + { + SetFieldUINT16Value(13, totalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDescentValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalDescent(void) const + { + return GetFieldUINT16Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDescent(FIT_UINT16 totalDescent) + { + SetFieldUINT16Value(14, totalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLatValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLat(void) const + { + return GetFieldSINT32Value(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLat(FIT_SINT32 startPositionLat) + { + SetFieldSINT32Value(21, startPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPositionLongValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetStartPositionLong(void) const + { + return GetFieldSINT32Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetStartPositionLong(FIT_SINT32 startPositionLong) + { + SetFieldSINT32Value(22, startPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLatValid() const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLat(void) const + { + return GetFieldSINT32Value(23, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLat(FIT_SINT32 endPositionLat) + { + SetFieldSINT32Value(23, endPositionLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_position_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPositionLongValid() const + { + const Field* field = GetField(24); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetEndPositionLong(void) const + { + return GetFieldSINT32Value(24, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_position_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetEndPositionLong(FIT_SINT32 endPositionLong) + { + SetFieldSINT32Value(24, endPositionLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSpeedValid() const + { + const Field* field = GetField(25); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSpeed(void) const + { + return GetFieldFLOAT32Value(25, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxSpeed(FIT_FLOAT32 maxSpeed) + { + SetFieldFLOAT32Value(25, maxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vert_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVertSpeedValid() const + { + const Field* field = GetField(26); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vert_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVertSpeed(void) const + { + return GetFieldFLOAT32Value(26, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vert_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgVertSpeed(FIT_FLOAT32 avgVertSpeed) + { + SetFieldFLOAT32Value(26, avgVertSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndTimeValid() const + { + const Field* field = GetField(27); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetEndTime(void) const + { + return GetFieldUINT32Value(27, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_time field + /////////////////////////////////////////////////////////////////////// + void SetEndTime(FIT_DATE_TIME endTime) + { + SetFieldUINT32Value(27, endTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCaloriesValid() const + { + const Field* field = GetField(28); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalCalories(void) const + { + return GetFieldUINT32Value(28, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalCalories(FIT_UINT32 totalCalories) + { + SetFieldUINT32Value(28, totalCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_elevation field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartElevationValid() const + { + const Field* field = GetField(74); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_elevation field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStartElevation(void) const + { + return GetFieldFLOAT32Value(74, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_elevation field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetStartElevation(FIT_FLOAT32 startElevation) + { + SetFieldFLOAT32Value(74, startElevation, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_moving_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalMovingTimeValid() const + { + const Field* field = GetField(110); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalMovingTime(void) const + { + return GetFieldFLOAT32Value(110, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalMovingTime(FIT_FLOAT32 totalMovingTime) + { + SetFieldFLOAT32Value(110, totalMovingTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SPLIT_MESG_HPP) diff --git a/fit_split_mesg_listener.hpp b/fit_split_mesg_listener.hpp new file mode 100644 index 0000000..7d9f68b --- /dev/null +++ b/fit_split_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPLIT_MESG_LISTENER_HPP) +#define FIT_SPLIT_MESG_LISTENER_HPP + +#include "fit_split_mesg.hpp" + +namespace fit +{ + +class SplitMesgListener +{ +public: + virtual ~SplitMesgListener() {} + virtual void OnMesg(SplitMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SPLIT_MESG_LISTENER_HPP) diff --git a/fit_split_summary_mesg.hpp b/fit_split_summary_mesg.hpp new file mode 100644 index 0000000..e82f429 --- /dev/null +++ b/fit_split_summary_mesg.hpp @@ -0,0 +1,512 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPLIT_SUMMARY_MESG_HPP) +#define FIT_SPLIT_SUMMARY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SplitSummaryMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 SplitType = 0; + static const FIT_UINT8 NumSplits = 3; + static const FIT_UINT8 TotalTimerTime = 4; + static const FIT_UINT8 TotalDistance = 5; + static const FIT_UINT8 AvgSpeed = 6; + static const FIT_UINT8 MaxSpeed = 7; + static const FIT_UINT8 TotalAscent = 8; + static const FIT_UINT8 TotalDescent = 9; + static const FIT_UINT8 AvgHeartRate = 10; + static const FIT_UINT8 MaxHeartRate = 11; + static const FIT_UINT8 AvgVertSpeed = 12; + static const FIT_UINT8 TotalCalories = 13; + static const FIT_UINT8 TotalMovingTime = 77; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SplitSummaryMesg(void) : Mesg(Profile::MESG_SPLIT_SUMMARY) + { + } + + SplitSummaryMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of split_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSplitTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns split_type field + /////////////////////////////////////////////////////////////////////// + FIT_SPLIT_TYPE GetSplitType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set split_type field + /////////////////////////////////////////////////////////////////////// + void SetSplitType(FIT_SPLIT_TYPE splitType) + { + SetFieldENUMValue(0, splitType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_splits field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumSplitsValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_splits field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumSplits(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_splits field + /////////////////////////////////////////////////////////////////////// + void SetNumSplits(FIT_UINT16 numSplits) + { + SetFieldUINT16Value(3, numSplits, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalTimerTimeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_timer_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalTimerTime(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_timer_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalTimerTime(FIT_FLOAT32 totalTimerTime) + { + SetFieldFLOAT32Value(4, totalTimerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDistanceValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalDistance(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDistance(FIT_FLOAT32 totalDistance) + { + SetFieldFLOAT32Value(5, totalDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgSpeedValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgSpeed(void) const + { + return GetFieldFLOAT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgSpeed(FIT_FLOAT32 avgSpeed) + { + SetFieldFLOAT32Value(6, avgSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxSpeedValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMaxSpeed(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetMaxSpeed(FIT_FLOAT32 maxSpeed) + { + SetFieldFLOAT32Value(7, maxSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_ascent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalAscentValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalAscent(void) const + { + return GetFieldUINT16Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_ascent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalAscent(FIT_UINT16 totalAscent) + { + SetFieldUINT16Value(8, totalAscent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_descent field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalDescentValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTotalDescent(void) const + { + return GetFieldUINT16Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_descent field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTotalDescent(FIT_UINT16 totalDescent) + { + SetFieldUINT16Value(9, totalDescent, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgHeartRateValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAvgHeartRate(void) const + { + return GetFieldUINT8Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetAvgHeartRate(FIT_UINT8 avgHeartRate) + { + SetFieldUINT8Value(10, avgHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxHeartRateValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxHeartRate(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetMaxHeartRate(FIT_UINT8 maxHeartRate) + { + SetFieldUINT8Value(11, maxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of avg_vert_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAvgVertSpeedValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns avg_vert_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetAvgVertSpeed(void) const + { + return GetFieldFLOAT32Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set avg_vert_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetAvgVertSpeed(FIT_FLOAT32 avgVertSpeed) + { + SetFieldFLOAT32Value(12, avgVertSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalCaloriesValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTotalCalories(void) const + { + return GetFieldUINT32Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetTotalCalories(FIT_UINT32 totalCalories) + { + SetFieldUINT32Value(13, totalCalories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of total_moving_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTotalMovingTimeValid() const + { + const Field* field = GetField(77); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTotalMovingTime(void) const + { + return GetFieldFLOAT32Value(77, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set total_moving_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTotalMovingTime(FIT_FLOAT32 totalMovingTime) + { + SetFieldFLOAT32Value(77, totalMovingTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SPLIT_SUMMARY_MESG_HPP) diff --git a/fit_split_summary_mesg_listener.hpp b/fit_split_summary_mesg_listener.hpp new file mode 100644 index 0000000..e4a5f30 --- /dev/null +++ b/fit_split_summary_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPLIT_SUMMARY_MESG_LISTENER_HPP) +#define FIT_SPLIT_SUMMARY_MESG_LISTENER_HPP + +#include "fit_split_summary_mesg.hpp" + +namespace fit +{ + +class SplitSummaryMesgListener +{ +public: + virtual ~SplitSummaryMesgListener() {} + virtual void OnMesg(SplitSummaryMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SPLIT_SUMMARY_MESG_LISTENER_HPP) diff --git a/fit_spo2_data_mesg.hpp b/fit_spo2_data_mesg.hpp new file mode 100644 index 0000000..af33ec8 --- /dev/null +++ b/fit_spo2_data_mesg.hpp @@ -0,0 +1,176 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPO2_DATA_MESG_HPP) +#define FIT_SPO2_DATA_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class Spo2DataMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ReadingSpo2 = 0; + static const FIT_UINT8 ReadingConfidence = 1; + static const FIT_UINT8 Mode = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + Spo2DataMesg(void) : Mesg(Profile::MESG_SPO2_DATA) + { + } + + Spo2DataMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reading_spo2 field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReadingSpo2Valid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reading_spo2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetReadingSpo2(void) const + { + return GetFieldUINT8Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reading_spo2 field + // Units: percent + /////////////////////////////////////////////////////////////////////// + void SetReadingSpo2(FIT_UINT8 readingSpo2) + { + SetFieldUINT8Value(0, readingSpo2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reading_confidence field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReadingConfidenceValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reading_confidence field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetReadingConfidence(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reading_confidence field + /////////////////////////////////////////////////////////////////////// + void SetReadingConfidence(FIT_UINT8 readingConfidence) + { + SetFieldUINT8Value(1, readingConfidence, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsModeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mode field + // Comment: Mode when data was captured + /////////////////////////////////////////////////////////////////////// + FIT_SPO2_MEASUREMENT_TYPE GetMode(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mode field + // Comment: Mode when data was captured + /////////////////////////////////////////////////////////////////////// + void SetMode(FIT_SPO2_MEASUREMENT_TYPE mode) + { + SetFieldENUMValue(2, mode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SPO2_DATA_MESG_HPP) diff --git a/fit_spo2_data_mesg_listener.hpp b/fit_spo2_data_mesg_listener.hpp new file mode 100644 index 0000000..2dc3508 --- /dev/null +++ b/fit_spo2_data_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPO2_DATA_MESG_LISTENER_HPP) +#define FIT_SPO2_DATA_MESG_LISTENER_HPP + +#include "fit_spo2_data_mesg.hpp" + +namespace fit +{ + +class Spo2DataMesgListener +{ +public: + virtual ~Spo2DataMesgListener() {} + virtual void OnMesg(Spo2DataMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SPO2_DATA_MESG_LISTENER_HPP) diff --git a/fit_sport_mesg.hpp b/fit_sport_mesg.hpp new file mode 100644 index 0000000..7518336 --- /dev/null +++ b/fit_sport_mesg.hpp @@ -0,0 +1,138 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPORT_MESG_HPP) +#define FIT_SPORT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class SportMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Sport = 0; + static const FIT_UINT8 SubSport = 1; + static const FIT_UINT8 Name = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + SportMesg(void) : Mesg(Profile::MESG_SPORT) + { + } + + SportMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(0, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(1, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNameValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetName(void) const + { + return GetFieldSTRINGValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set name field + /////////////////////////////////////////////////////////////////////// + void SetName(FIT_WSTRING name) + { + SetFieldSTRINGValue(3, name, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_SPORT_MESG_HPP) diff --git a/fit_sport_mesg_listener.hpp b/fit_sport_mesg_listener.hpp new file mode 100644 index 0000000..3d9c2ea --- /dev/null +++ b/fit_sport_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_SPORT_MESG_LISTENER_HPP) +#define FIT_SPORT_MESG_LISTENER_HPP + +#include "fit_sport_mesg.hpp" + +namespace fit +{ + +class SportMesgListener +{ +public: + virtual ~SportMesgListener() {} + virtual void OnMesg(SportMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_SPORT_MESG_LISTENER_HPP) diff --git a/fit_stress_level_mesg.hpp b/fit_stress_level_mesg.hpp new file mode 100644 index 0000000..300598c --- /dev/null +++ b/fit_stress_level_mesg.hpp @@ -0,0 +1,110 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_STRESS_LEVEL_MESG_HPP) +#define FIT_STRESS_LEVEL_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class StressLevelMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 StressLevelValue = 0; + static const FIT_UINT8 StressLevelTime = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + StressLevelMesg(void) : Mesg(Profile::MESG_STRESS_LEVEL) + { + } + + StressLevelMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stress_level_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStressLevelValueValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stress_level_value field + /////////////////////////////////////////////////////////////////////// + FIT_SINT16 GetStressLevelValue(void) const + { + return GetFieldSINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stress_level_value field + /////////////////////////////////////////////////////////////////////// + void SetStressLevelValue(FIT_SINT16 stressLevelValue) + { + SetFieldSINT16Value(0, stressLevelValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of stress_level_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStressLevelTimeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns stress_level_time field + // Units: s + // Comment: Time stress score was calculated + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStressLevelTime(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set stress_level_time field + // Units: s + // Comment: Time stress score was calculated + /////////////////////////////////////////////////////////////////////// + void SetStressLevelTime(FIT_DATE_TIME stressLevelTime) + { + SetFieldUINT32Value(1, stressLevelTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_STRESS_LEVEL_MESG_HPP) diff --git a/fit_stress_level_mesg_listener.hpp b/fit_stress_level_mesg_listener.hpp new file mode 100644 index 0000000..9b7d38f --- /dev/null +++ b/fit_stress_level_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_STRESS_LEVEL_MESG_LISTENER_HPP) +#define FIT_STRESS_LEVEL_MESG_LISTENER_HPP + +#include "fit_stress_level_mesg.hpp" + +namespace fit +{ + +class StressLevelMesgListener +{ +public: + virtual ~StressLevelMesgListener() {} + virtual void OnMesg(StressLevelMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_STRESS_LEVEL_MESG_LISTENER_HPP) diff --git a/fit_tank_summary_mesg.hpp b/fit_tank_summary_mesg.hpp new file mode 100644 index 0000000..db21334 --- /dev/null +++ b/fit_tank_summary_mesg.hpp @@ -0,0 +1,210 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TANK_SUMMARY_MESG_HPP) +#define FIT_TANK_SUMMARY_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TankSummaryMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Sensor = 0; + static const FIT_UINT8 StartPressure = 1; + static const FIT_UINT8 EndPressure = 2; + static const FIT_UINT8 VolumeUsed = 3; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TankSummaryMesg(void) : Mesg(Profile::MESG_TANK_SUMMARY) + { + } + + TankSummaryMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sensor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSensorValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sensor field + /////////////////////////////////////////////////////////////////////// + FIT_ANT_CHANNEL_ID GetSensor(void) const + { + return GetFieldUINT32ZValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sensor field + /////////////////////////////////////////////////////////////////////// + void SetSensor(FIT_ANT_CHANNEL_ID sensor) + { + SetFieldUINT32ZValue(0, sensor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartPressureValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_pressure field + // Units: bar + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetStartPressure(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_pressure field + // Units: bar + /////////////////////////////////////////////////////////////////////// + void SetStartPressure(FIT_FLOAT32 startPressure) + { + SetFieldFLOAT32Value(1, startPressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndPressureValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_pressure field + // Units: bar + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetEndPressure(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_pressure field + // Units: bar + /////////////////////////////////////////////////////////////////////// + void SetEndPressure(FIT_FLOAT32 endPressure) + { + SetFieldFLOAT32Value(2, endPressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of volume_used field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVolumeUsedValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns volume_used field + // Units: L + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVolumeUsed(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set volume_used field + // Units: L + /////////////////////////////////////////////////////////////////////// + void SetVolumeUsed(FIT_FLOAT32 volumeUsed) + { + SetFieldFLOAT32Value(3, volumeUsed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TANK_SUMMARY_MESG_HPP) diff --git a/fit_tank_summary_mesg_listener.hpp b/fit_tank_summary_mesg_listener.hpp new file mode 100644 index 0000000..721449b --- /dev/null +++ b/fit_tank_summary_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TANK_SUMMARY_MESG_LISTENER_HPP) +#define FIT_TANK_SUMMARY_MESG_LISTENER_HPP + +#include "fit_tank_summary_mesg.hpp" + +namespace fit +{ + +class TankSummaryMesgListener +{ +public: + virtual ~TankSummaryMesgListener() {} + virtual void OnMesg(TankSummaryMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TANK_SUMMARY_MESG_LISTENER_HPP) diff --git a/fit_tank_update_mesg.hpp b/fit_tank_update_mesg.hpp new file mode 100644 index 0000000..e023441 --- /dev/null +++ b/fit_tank_update_mesg.hpp @@ -0,0 +1,142 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TANK_UPDATE_MESG_HPP) +#define FIT_TANK_UPDATE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TankUpdateMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Sensor = 0; + static const FIT_UINT8 Pressure = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TankUpdateMesg(void) : Mesg(Profile::MESG_TANK_UPDATE) + { + } + + TankUpdateMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sensor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSensorValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sensor field + /////////////////////////////////////////////////////////////////////// + FIT_ANT_CHANNEL_ID GetSensor(void) const + { + return GetFieldUINT32ZValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sensor field + /////////////////////////////////////////////////////////////////////// + void SetSensor(FIT_ANT_CHANNEL_ID sensor) + { + SetFieldUINT32ZValue(0, sensor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pressure field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPressureValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pressure field + // Units: bar + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPressure(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pressure field + // Units: bar + /////////////////////////////////////////////////////////////////////// + void SetPressure(FIT_FLOAT32 pressure) + { + SetFieldFLOAT32Value(1, pressure, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TANK_UPDATE_MESG_HPP) diff --git a/fit_tank_update_mesg_listener.hpp b/fit_tank_update_mesg_listener.hpp new file mode 100644 index 0000000..247cf8a --- /dev/null +++ b/fit_tank_update_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TANK_UPDATE_MESG_LISTENER_HPP) +#define FIT_TANK_UPDATE_MESG_LISTENER_HPP + +#include "fit_tank_update_mesg.hpp" + +namespace fit +{ + +class TankUpdateMesgListener +{ +public: + virtual ~TankUpdateMesgListener() {} + virtual void OnMesg(TankUpdateMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TANK_UPDATE_MESG_LISTENER_HPP) diff --git a/fit_three_d_sensor_calibration_mesg.hpp b/fit_three_d_sensor_calibration_mesg.hpp new file mode 100644 index 0000000..9b2b9a0 --- /dev/null +++ b/fit_three_d_sensor_calibration_mesg.hpp @@ -0,0 +1,382 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_THREE_D_SENSOR_CALIBRATION_MESG_HPP) +#define FIT_THREE_D_SENSOR_CALIBRATION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ThreeDSensorCalibrationMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 SensorType = 0; + static const FIT_UINT8 CalibrationFactor = 1; + static const FIT_UINT8 CalibrationDivisor = 2; + static const FIT_UINT8 LevelShift = 3; + static const FIT_UINT8 OffsetCal = 4; + static const FIT_UINT8 OrientationMatrix = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ThreeDSensorCalibrationMesg(void) : Mesg(Profile::MESG_THREE_D_SENSOR_CALIBRATION) + { + } + + ThreeDSensorCalibrationMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sensor_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSensorTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sensor_type field + // Comment: Indicates which sensor the calibration is for + /////////////////////////////////////////////////////////////////////// + FIT_SENSOR_TYPE GetSensorType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sensor_type field + // Comment: Indicates which sensor the calibration is for + /////////////////////////////////////////////////////////////////////// + void SetSensorType(FIT_SENSOR_TYPE sensorType) + { + SetFieldENUMValue(0, sensorType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibration_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibrationFactorValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibration_factor field + // Comment: Calibration factor used to convert from raw ADC value to degrees, g, etc. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCalibrationFactor(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibration_factor field + // Comment: Calibration factor used to convert from raw ADC value to degrees, g, etc. + /////////////////////////////////////////////////////////////////////// + void SetCalibrationFactor(FIT_UINT32 calibrationFactor) + { + SetFieldUINT32Value(1, calibrationFactor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of accel_cal_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAccelCalFactorValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACCEL_CAL_FACTOR ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACCEL_CAL_FACTOR); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns accel_cal_factor field + // Units: g + // Comment: Accelerometer calibration factor + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetAccelCalFactor(void) const + { + return GetFieldUINT32Value(1, 0, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACCEL_CAL_FACTOR); + } + + /////////////////////////////////////////////////////////////////////// + // Set accel_cal_factor field + // Units: g + // Comment: Accelerometer calibration factor + /////////////////////////////////////////////////////////////////////// + void SetAccelCalFactor(FIT_UINT32 accelCalFactor) + { + SetFieldUINT32Value(1, accelCalFactor, 0, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_ACCEL_CAL_FACTOR); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gyro_cal_factor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGyroCalFactorValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_GYRO_CAL_FACTOR ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_GYRO_CAL_FACTOR); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns gyro_cal_factor field + // Units: deg/s + // Comment: Gyro calibration factor + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetGyroCalFactor(void) const + { + return GetFieldUINT32Value(1, 0, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_GYRO_CAL_FACTOR); + } + + /////////////////////////////////////////////////////////////////////// + // Set gyro_cal_factor field + // Units: deg/s + // Comment: Gyro calibration factor + /////////////////////////////////////////////////////////////////////// + void SetGyroCalFactor(FIT_UINT32 gyroCalFactor) + { + SetFieldUINT32Value(1, gyroCalFactor, 0, (FIT_UINT16) Profile::THREE_D_SENSOR_CALIBRATION_MESG_CALIBRATION_FACTOR_FIELD_GYRO_CAL_FACTOR); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calibration_divisor field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCalibrationDivisorValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calibration_divisor field + // Units: counts + // Comment: Calibration factor divisor + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCalibrationDivisor(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calibration_divisor field + // Units: counts + // Comment: Calibration factor divisor + /////////////////////////////////////////////////////////////////////// + void SetCalibrationDivisor(FIT_UINT32 calibrationDivisor) + { + SetFieldUINT32Value(2, calibrationDivisor, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of level_shift field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLevelShiftValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns level_shift field + // Comment: Level shift value used to shift the ADC value back into range + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetLevelShift(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set level_shift field + // Comment: Level shift value used to shift the ADC value back into range + /////////////////////////////////////////////////////////////////////// + void SetLevelShift(FIT_UINT32 levelShift) + { + SetFieldUINT32Value(3, levelShift, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of offset_cal + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumOffsetCal(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of offset_cal field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOffsetCalValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns offset_cal field + // Comment: Internal calibration factors, one for each: xy, yx, zx + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetOffsetCal(FIT_UINT8 index) const + { + return GetFieldSINT32Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set offset_cal field + // Comment: Internal calibration factors, one for each: xy, yx, zx + /////////////////////////////////////////////////////////////////////// + void SetOffsetCal(FIT_UINT8 index, FIT_SINT32 offsetCal) + { + SetFieldSINT32Value(4, offsetCal, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of orientation_matrix + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumOrientationMatrix(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of orientation_matrix field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsOrientationMatrixValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns orientation_matrix field + // Comment: 3 x 3 rotation matrix (row major) + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetOrientationMatrix(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set orientation_matrix field + // Comment: 3 x 3 rotation matrix (row major) + /////////////////////////////////////////////////////////////////////// + void SetOrientationMatrix(FIT_UINT8 index, FIT_FLOAT32 orientationMatrix) + { + SetFieldFLOAT32Value(5, orientationMatrix, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_THREE_D_SENSOR_CALIBRATION_MESG_HPP) diff --git a/fit_three_d_sensor_calibration_mesg_listener.hpp b/fit_three_d_sensor_calibration_mesg_listener.hpp new file mode 100644 index 0000000..b860d1c --- /dev/null +++ b/fit_three_d_sensor_calibration_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_THREE_D_SENSOR_CALIBRATION_MESG_LISTENER_HPP) +#define FIT_THREE_D_SENSOR_CALIBRATION_MESG_LISTENER_HPP + +#include "fit_three_d_sensor_calibration_mesg.hpp" + +namespace fit +{ + +class ThreeDSensorCalibrationMesgListener +{ +public: + virtual ~ThreeDSensorCalibrationMesgListener() {} + virtual void OnMesg(ThreeDSensorCalibrationMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_THREE_D_SENSOR_CALIBRATION_MESG_LISTENER_HPP) diff --git a/fit_time_in_zone_mesg.hpp b/fit_time_in_zone_mesg.hpp new file mode 100644 index 0000000..9bc1288 --- /dev/null +++ b/fit_time_in_zone_mesg.hpp @@ -0,0 +1,668 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TIME_IN_ZONE_MESG_HPP) +#define FIT_TIME_IN_ZONE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TimeInZoneMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ReferenceMesg = 0; + static const FIT_UINT8 ReferenceIndex = 1; + static const FIT_UINT8 TimeInHrZone = 2; + static const FIT_UINT8 TimeInSpeedZone = 3; + static const FIT_UINT8 TimeInCadenceZone = 4; + static const FIT_UINT8 TimeInPowerZone = 5; + static const FIT_UINT8 HrZoneHighBoundary = 6; + static const FIT_UINT8 SpeedZoneHighBoundary = 7; + static const FIT_UINT8 CadenceZoneHighBondary = 8; + static const FIT_UINT8 PowerZoneHighBoundary = 9; + static const FIT_UINT8 HrCalcType = 10; + static const FIT_UINT8 MaxHeartRate = 11; + static const FIT_UINT8 RestingHeartRate = 12; + static const FIT_UINT8 ThresholdHeartRate = 13; + static const FIT_UINT8 PwrCalcType = 14; + static const FIT_UINT8 FunctionalThresholdPower = 15; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TimeInZoneMesg(void) : Mesg(Profile::MESG_TIME_IN_ZONE) + { + } + + TimeInZoneMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reference_mesg field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReferenceMesgValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reference_mesg field + /////////////////////////////////////////////////////////////////////// + FIT_MESG_NUM GetReferenceMesg(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reference_mesg field + /////////////////////////////////////////////////////////////////////// + void SetReferenceMesg(FIT_MESG_NUM referenceMesg) + { + SetFieldUINT16Value(0, referenceMesg, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of reference_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReferenceIndexValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns reference_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetReferenceIndex(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set reference_index field + /////////////////////////////////////////////////////////////////////// + void SetReferenceIndex(FIT_MESSAGE_INDEX referenceIndex) + { + SetFieldUINT16Value(1, referenceIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_hr_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInHrZone(void) const + { + return GetFieldNumValues(2, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_hr_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInHrZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInHrZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(2, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_hr_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInHrZone(FIT_UINT8 index, FIT_FLOAT32 timeInHrZone) + { + SetFieldFLOAT32Value(2, timeInHrZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_speed_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInSpeedZone(void) const + { + return GetFieldNumValues(3, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_speed_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInSpeedZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInSpeedZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(3, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_speed_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInSpeedZone(FIT_UINT8 index, FIT_FLOAT32 timeInSpeedZone) + { + SetFieldFLOAT32Value(3, timeInSpeedZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_cadence_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInCadenceZone(void) const + { + return GetFieldNumValues(4, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_cadence_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInCadenceZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInCadenceZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(4, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_cadence_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInCadenceZone(FIT_UINT8 index, FIT_FLOAT32 timeInCadenceZone) + { + SetFieldFLOAT32Value(4, timeInCadenceZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of time_in_power_zone + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumTimeInPowerZone(void) const + { + return GetFieldNumValues(5, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_in_power_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeInPowerZoneValid(FIT_UINT8 index) const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTimeInPowerZone(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(5, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_in_power_zone field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimeInPowerZone(FIT_UINT8 index, FIT_FLOAT32 timeInPowerZone) + { + SetFieldFLOAT32Value(5, timeInPowerZone, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of hr_zone_high_boundary + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumHrZoneHighBoundary(void) const + { + return GetFieldNumValues(6, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_zone_high_boundary field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrZoneHighBoundaryValid(FIT_UINT8 index) const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hr_zone_high_boundary field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetHrZoneHighBoundary(FIT_UINT8 index) const + { + return GetFieldUINT8Value(6, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_zone_high_boundary field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetHrZoneHighBoundary(FIT_UINT8 index, FIT_UINT8 hrZoneHighBoundary) + { + SetFieldUINT8Value(6, hrZoneHighBoundary, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of speed_zone_high_boundary + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumSpeedZoneHighBoundary(void) const + { + return GetFieldNumValues(7, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_zone_high_boundary field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedZoneHighBoundaryValid(FIT_UINT8 index) const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed_zone_high_boundary field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSpeedZoneHighBoundary(FIT_UINT8 index) const + { + return GetFieldFLOAT32Value(7, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_zone_high_boundary field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSpeedZoneHighBoundary(FIT_UINT8 index, FIT_FLOAT32 speedZoneHighBoundary) + { + SetFieldFLOAT32Value(7, speedZoneHighBoundary, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of cadence_zone_high_bondary + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumCadenceZoneHighBondary(void) const + { + return GetFieldNumValues(8, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of cadence_zone_high_bondary field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCadenceZoneHighBondaryValid(FIT_UINT8 index) const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns cadence_zone_high_bondary field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetCadenceZoneHighBondary(FIT_UINT8 index) const + { + return GetFieldUINT8Value(8, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set cadence_zone_high_bondary field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetCadenceZoneHighBondary(FIT_UINT8 index, FIT_UINT8 cadenceZoneHighBondary) + { + SetFieldUINT8Value(8, cadenceZoneHighBondary, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of power_zone_high_boundary + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumPowerZoneHighBoundary(void) const + { + return GetFieldNumValues(9, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power_zone_high_boundary field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerZoneHighBoundaryValid(FIT_UINT8 index) const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns power_zone_high_boundary field + // Units: watts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetPowerZoneHighBoundary(FIT_UINT8 index) const + { + return GetFieldUINT16Value(9, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set power_zone_high_boundary field + // Units: watts + /////////////////////////////////////////////////////////////////////// + void SetPowerZoneHighBoundary(FIT_UINT8 index, FIT_UINT16 powerZoneHighBoundary) + { + SetFieldUINT16Value(9, powerZoneHighBoundary, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_calc_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrCalcTypeValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hr_calc_type field + /////////////////////////////////////////////////////////////////////// + FIT_HR_ZONE_CALC GetHrCalcType(void) const + { + return GetFieldENUMValue(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_calc_type field + /////////////////////////////////////////////////////////////////////// + void SetHrCalcType(FIT_HR_ZONE_CALC hrCalcType) + { + SetFieldENUMValue(10, hrCalcType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxHeartRateValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_heart_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxHeartRate(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_heart_rate field + /////////////////////////////////////////////////////////////////////// + void SetMaxHeartRate(FIT_UINT8 maxHeartRate) + { + SetFieldUINT8Value(11, maxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of resting_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRestingHeartRateValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns resting_heart_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRestingHeartRate(void) const + { + return GetFieldUINT8Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set resting_heart_rate field + /////////////////////////////////////////////////////////////////////// + void SetRestingHeartRate(FIT_UINT8 restingHeartRate) + { + SetFieldUINT8Value(12, restingHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of threshold_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsThresholdHeartRateValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns threshold_heart_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetThresholdHeartRate(void) const + { + return GetFieldUINT8Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set threshold_heart_rate field + /////////////////////////////////////////////////////////////////////// + void SetThresholdHeartRate(FIT_UINT8 thresholdHeartRate) + { + SetFieldUINT8Value(13, thresholdHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pwr_calc_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPwrCalcTypeValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pwr_calc_type field + /////////////////////////////////////////////////////////////////////// + FIT_PWR_ZONE_CALC GetPwrCalcType(void) const + { + return GetFieldENUMValue(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pwr_calc_type field + /////////////////////////////////////////////////////////////////////// + void SetPwrCalcType(FIT_PWR_ZONE_CALC pwrCalcType) + { + SetFieldENUMValue(14, pwrCalcType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of functional_threshold_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFunctionalThresholdPowerValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns functional_threshold_power field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetFunctionalThresholdPower(void) const + { + return GetFieldUINT16Value(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set functional_threshold_power field + /////////////////////////////////////////////////////////////////////// + void SetFunctionalThresholdPower(FIT_UINT16 functionalThresholdPower) + { + SetFieldUINT16Value(15, functionalThresholdPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TIME_IN_ZONE_MESG_HPP) diff --git a/fit_time_in_zone_mesg_listener.hpp b/fit_time_in_zone_mesg_listener.hpp new file mode 100644 index 0000000..97abbe0 --- /dev/null +++ b/fit_time_in_zone_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TIME_IN_ZONE_MESG_LISTENER_HPP) +#define FIT_TIME_IN_ZONE_MESG_LISTENER_HPP + +#include "fit_time_in_zone_mesg.hpp" + +namespace fit +{ + +class TimeInZoneMesgListener +{ +public: + virtual ~TimeInZoneMesgListener() {} + virtual void OnMesg(TimeInZoneMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TIME_IN_ZONE_MESG_LISTENER_HPP) diff --git a/fit_timestamp_correlation_mesg.hpp b/fit_timestamp_correlation_mesg.hpp new file mode 100644 index 0000000..11ebb23 --- /dev/null +++ b/fit_timestamp_correlation_mesg.hpp @@ -0,0 +1,294 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TIMESTAMP_CORRELATION_MESG_HPP) +#define FIT_TIMESTAMP_CORRELATION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TimestampCorrelationMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 FractionalTimestamp = 0; + static const FIT_UINT8 SystemTimestamp = 1; + static const FIT_UINT8 FractionalSystemTimestamp = 2; + static const FIT_UINT8 LocalTimestamp = 3; + static const FIT_UINT8 TimestampMs = 4; + static const FIT_UINT8 SystemTimestampMs = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TimestampCorrelationMesg(void) : Mesg(Profile::MESG_TIMESTAMP_CORRELATION) + { + } + + TimestampCorrelationMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of UTC timestamp at the time the system timestamp was recorded. + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of UTC timestamp at the time the system timestamp was recorded. + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fractional_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFractionalTimestampValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fractional_timestamp field + // Units: s + // Comment: Fractional part of the UTC timestamp at the time the system timestamp was recorded. + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFractionalTimestamp(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fractional_timestamp field + // Units: s + // Comment: Fractional part of the UTC timestamp at the time the system timestamp was recorded. + /////////////////////////////////////////////////////////////////////// + void SetFractionalTimestamp(FIT_FLOAT32 fractionalTimestamp) + { + SetFieldFLOAT32Value(0, fractionalTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of system_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSystemTimestampValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns system_timestamp field + // Units: s + // Comment: Whole second part of the system timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetSystemTimestamp(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set system_timestamp field + // Units: s + // Comment: Whole second part of the system timestamp + /////////////////////////////////////////////////////////////////////// + void SetSystemTimestamp(FIT_DATE_TIME systemTimestamp) + { + SetFieldUINT32Value(1, systemTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of fractional_system_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFractionalSystemTimestampValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns fractional_system_timestamp field + // Units: s + // Comment: Fractional part of the system timestamp + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetFractionalSystemTimestamp(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set fractional_system_timestamp field + // Units: s + // Comment: Fractional part of the system timestamp + /////////////////////////////////////////////////////////////////////// + void SetFractionalSystemTimestamp(FIT_FLOAT32 fractionalSystemTimestamp) + { + SetFieldFLOAT32Value(2, fractionalSystemTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalTimestampValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns local_timestamp field + // Units: s + // Comment: timestamp epoch expressed in local time used to convert timestamps to local time + /////////////////////////////////////////////////////////////////////// + FIT_LOCAL_DATE_TIME GetLocalTimestamp(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_timestamp field + // Units: s + // Comment: timestamp epoch expressed in local time used to convert timestamps to local time + /////////////////////////////////////////////////////////////////////// + void SetLocalTimestamp(FIT_LOCAL_DATE_TIME localTimestamp) + { + SetFieldUINT32Value(3, localTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the UTC timestamp at the time the system timestamp was recorded. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the UTC timestamp at the time the system timestamp was recorded. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(4, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of system_timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSystemTimestampMsValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns system_timestamp_ms field + // Units: ms + // Comment: Millisecond part of the system timestamp + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSystemTimestampMs(void) const + { + return GetFieldUINT16Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set system_timestamp_ms field + // Units: ms + // Comment: Millisecond part of the system timestamp + /////////////////////////////////////////////////////////////////////// + void SetSystemTimestampMs(FIT_UINT16 systemTimestampMs) + { + SetFieldUINT16Value(5, systemTimestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TIMESTAMP_CORRELATION_MESG_HPP) diff --git a/fit_timestamp_correlation_mesg_listener.hpp b/fit_timestamp_correlation_mesg_listener.hpp new file mode 100644 index 0000000..2d47354 --- /dev/null +++ b/fit_timestamp_correlation_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TIMESTAMP_CORRELATION_MESG_LISTENER_HPP) +#define FIT_TIMESTAMP_CORRELATION_MESG_LISTENER_HPP + +#include "fit_timestamp_correlation_mesg.hpp" + +namespace fit +{ + +class TimestampCorrelationMesgListener +{ +public: + virtual ~TimestampCorrelationMesgListener() {} + virtual void OnMesg(TimestampCorrelationMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TIMESTAMP_CORRELATION_MESG_LISTENER_HPP) diff --git a/fit_totals_mesg.hpp b/fit_totals_mesg.hpp new file mode 100644 index 0000000..3063306 --- /dev/null +++ b/fit_totals_mesg.hpp @@ -0,0 +1,378 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TOTALS_MESG_HPP) +#define FIT_TOTALS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TotalsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimerTime = 0; + static const FIT_UINT8 Distance = 1; + static const FIT_UINT8 Calories = 2; + static const FIT_UINT8 Sport = 3; + static const FIT_UINT8 ElapsedTime = 4; + static const FIT_UINT8 Sessions = 5; + static const FIT_UINT8 ActiveTime = 6; + static const FIT_UINT8 SportIndex = 9; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TotalsMesg(void) : Mesg(Profile::MESG_TOTALS) + { + } + + TotalsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timer_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimerTimeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timer_time field + // Units: s + // Comment: Excludes pauses + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTimerTime(void) const + { + return GetFieldUINT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timer_time field + // Units: s + // Comment: Excludes pauses + /////////////////////////////////////////////////////////////////////// + void SetTimerTime(FIT_UINT32 timerTime) + { + SetFieldUINT32Value(0, timerTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistanceValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDistance(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDistance(FIT_UINT32 distance) + { + SetFieldUINT32Value(1, distance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCaloriesValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCalories(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set calories field + // Units: kcal + /////////////////////////////////////////////////////////////////////// + void SetCalories(FIT_UINT32 calories) + { + SetFieldUINT32Value(2, calories, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(3, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of elapsed_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsElapsedTimeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns elapsed_time field + // Units: s + // Comment: Includes pauses + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetElapsedTime(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set elapsed_time field + // Units: s + // Comment: Includes pauses + /////////////////////////////////////////////////////////////////////// + void SetElapsedTime(FIT_UINT32 elapsedTime) + { + SetFieldUINT32Value(4, elapsedTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sessions field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSessionsValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sessions field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetSessions(void) const + { + return GetFieldUINT16Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sessions field + /////////////////////////////////////////////////////////////////////// + void SetSessions(FIT_UINT16 sessions) + { + SetFieldUINT16Value(5, sessions, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveTimeValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetActiveTime(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetActiveTime(FIT_UINT32 activeTime) + { + SetFieldUINT32Value(6, activeTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportIndexValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetSportIndex(void) const + { + return GetFieldUINT8Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport_index field + /////////////////////////////////////////////////////////////////////// + void SetSportIndex(FIT_UINT8 sportIndex) + { + SetFieldUINT8Value(9, sportIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TOTALS_MESG_HPP) diff --git a/fit_totals_mesg_listener.hpp b/fit_totals_mesg_listener.hpp new file mode 100644 index 0000000..1c03b1e --- /dev/null +++ b/fit_totals_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TOTALS_MESG_LISTENER_HPP) +#define FIT_TOTALS_MESG_LISTENER_HPP + +#include "fit_totals_mesg.hpp" + +namespace fit +{ + +class TotalsMesgListener +{ +public: + virtual ~TotalsMesgListener() {} + virtual void OnMesg(TotalsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TOTALS_MESG_LISTENER_HPP) diff --git a/fit_training_file_mesg.hpp b/fit_training_file_mesg.hpp new file mode 100644 index 0000000..49f5cea --- /dev/null +++ b/fit_training_file_mesg.hpp @@ -0,0 +1,308 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TRAINING_FILE_MESG_HPP) +#define FIT_TRAINING_FILE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TrainingFileMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Type = 0; + static const FIT_UINT8 Manufacturer = 1; + static const FIT_UINT8 Product = 2; + static const FIT_UINT8 SerialNumber = 3; + static const FIT_UINT8 TimeCreated = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TrainingFileMesg(void) : Mesg(Profile::MESG_TRAINING_FILE) + { + } + + TrainingFileMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + /////////////////////////////////////////////////////////////////////// + FIT_FILE GetType(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_FILE type) + { + SetFieldENUMValue(0, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of manufacturer field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsManufacturerValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns manufacturer field + /////////////////////////////////////////////////////////////////////// + FIT_MANUFACTURER GetManufacturer(void) const + { + return GetFieldUINT16Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set manufacturer field + /////////////////////////////////////////////////////////////////////// + void SetManufacturer(FIT_MANUFACTURER manufacturer) + { + SetFieldUINT16Value(1, manufacturer, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsProductValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns product field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetProduct(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set product field + /////////////////////////////////////////////////////////////////////// + void SetProduct(FIT_UINT16 product) + { + SetFieldUINT16Value(2, product, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of favero_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFaveroProductValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns favero_product field + /////////////////////////////////////////////////////////////////////// + FIT_FAVERO_PRODUCT GetFaveroProduct(void) const + { + return GetFieldUINT16Value(2, 0, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set favero_product field + /////////////////////////////////////////////////////////////////////// + void SetFaveroProduct(FIT_FAVERO_PRODUCT faveroProduct) + { + SetFieldUINT16Value(2, faveroProduct, 0, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_FAVERO_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of garmin_product field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGarminProductValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns garmin_product field + /////////////////////////////////////////////////////////////////////// + FIT_GARMIN_PRODUCT GetGarminProduct(void) const + { + return GetFieldUINT16Value(2, 0, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Set garmin_product field + /////////////////////////////////////////////////////////////////////// + void SetGarminProduct(FIT_GARMIN_PRODUCT garminProduct) + { + SetFieldUINT16Value(2, garminProduct, 0, (FIT_UINT16) Profile::TRAINING_FILE_MESG_PRODUCT_FIELD_GARMIN_PRODUCT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of serial_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSerialNumberValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns serial_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32Z GetSerialNumber(void) const + { + return GetFieldUINT32ZValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set serial_number field + /////////////////////////////////////////////////////////////////////// + void SetSerialNumber(FIT_UINT32Z serialNumber) + { + SetFieldUINT32ZValue(3, serialNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of time_created field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimeCreatedValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns time_created field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimeCreated(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set time_created field + /////////////////////////////////////////////////////////////////////// + void SetTimeCreated(FIT_DATE_TIME timeCreated) + { + SetFieldUINT32Value(4, timeCreated, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TRAINING_FILE_MESG_HPP) diff --git a/fit_training_file_mesg_listener.hpp b/fit_training_file_mesg_listener.hpp new file mode 100644 index 0000000..1c85164 --- /dev/null +++ b/fit_training_file_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TRAINING_FILE_MESG_LISTENER_HPP) +#define FIT_TRAINING_FILE_MESG_LISTENER_HPP + +#include "fit_training_file_mesg.hpp" + +namespace fit +{ + +class TrainingFileMesgListener +{ +public: + virtual ~TrainingFileMesgListener() {} + virtual void OnMesg(TrainingFileMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TRAINING_FILE_MESG_LISTENER_HPP) diff --git a/fit_training_settings_mesg.hpp b/fit_training_settings_mesg.hpp new file mode 100644 index 0000000..76d2c12 --- /dev/null +++ b/fit_training_settings_mesg.hpp @@ -0,0 +1,180 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TRAINING_SETTINGS_MESG_HPP) +#define FIT_TRAINING_SETTINGS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class TrainingSettingsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 TargetDistance = 31; + static const FIT_UINT8 TargetSpeed = 32; + static const FIT_UINT8 TargetTime = 33; + static const FIT_UINT8 PreciseTargetSpeed = 153; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + TrainingSettingsMesg(void) : Mesg(Profile::MESG_TRAINING_SETTINGS) + { + } + + TrainingSettingsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetDistanceValid() const + { + const Field* field = GetField(31); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns target_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTargetDistance(void) const + { + return GetFieldFLOAT32Value(31, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetTargetDistance(FIT_FLOAT32 targetDistance) + { + SetFieldFLOAT32Value(31, targetDistance, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetSpeedValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns target_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetTargetSpeed(void) const + { + return GetFieldFLOAT32Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetTargetSpeed(FIT_FLOAT32 targetSpeed) + { + SetFieldFLOAT32Value(32, targetSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetTimeValid() const + { + const Field* field = GetField(33); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns target_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetTime(void) const + { + return GetFieldUINT32Value(33, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTargetTime(FIT_UINT32 targetTime) + { + SetFieldUINT32Value(33, targetTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of precise_target_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPreciseTargetSpeedValid() const + { + const Field* field = GetField(153); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns precise_target_speed field + // Units: m/s + // Comment: A more precise target speed field + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPreciseTargetSpeed(void) const + { + return GetFieldFLOAT32Value(153, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set precise_target_speed field + // Units: m/s + // Comment: A more precise target speed field + /////////////////////////////////////////////////////////////////////// + void SetPreciseTargetSpeed(FIT_FLOAT32 preciseTargetSpeed) + { + SetFieldFLOAT32Value(153, preciseTargetSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_TRAINING_SETTINGS_MESG_HPP) diff --git a/fit_training_settings_mesg_listener.hpp b/fit_training_settings_mesg_listener.hpp new file mode 100644 index 0000000..967455d --- /dev/null +++ b/fit_training_settings_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_TRAINING_SETTINGS_MESG_LISTENER_HPP) +#define FIT_TRAINING_SETTINGS_MESG_LISTENER_HPP + +#include "fit_training_settings_mesg.hpp" + +namespace fit +{ + +class TrainingSettingsMesgListener +{ +public: + virtual ~TrainingSettingsMesgListener() {} + virtual void OnMesg(TrainingSettingsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_TRAINING_SETTINGS_MESG_LISTENER_HPP) diff --git a/fit_unicode.cpp b/fit_unicode.cpp new file mode 100644 index 0000000..6aa5dd5 --- /dev/null +++ b/fit_unicode.cpp @@ -0,0 +1,388 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#include "fit_config.hpp" +#include "fit_runtime_exception.hpp" +#include "fit_unicode.hpp" + +/////////////////////////////////////////////////////////////////////// +// Private Definitions +/////////////////////////////////////////////////////////////////////// + +// Encoding types. +typedef FIT_ENUM FIT_UNICODE_ENCODING; +#define FIT_UNICODE_ENCODING_UTF8 ((FIT_UNICODE_ENCODING)0) +#define FIT_UNICODE_ENCODING_UTF16 ((FIT_UNICODE_ENCODING)1) +#define FIT_UNICODE_ENCODING_UTF32 ((FIT_UNICODE_ENCODING)2) +#define FIT_UNICODE_ENCODING_INVALID FIT_ENUM_INVALID +#define FIT_UNICODE_ENCODING_COUNT 3 + +#if (FIT_WIDE_CHAR_SIZE == 1) +#define INTERNAL_UNICODE_ENCODING FIT_UNICODE_ENCODING_UTF8 +#elif (FIT_WIDE_CHAR_SIZE == 2) +#define INTERNAL_UNICODE_ENCODING FIT_UNICODE_ENCODING_UTF16 +#elif (FIT_WIDE_CHAR_SIZE == 4) +#define INTERNAL_UNICODE_ENCODING FIT_UNICODE_ENCODING_UTF32 +#else + #error "Wide character size not specified as 1, 2 or 4 bytes." +#endif + +// Conversion error codes. +typedef FIT_ENUM FIT_STRING_CONVERSION_ERROR; +#define FIT_STRING_CONVERSION_ERROR_UNICODE_INVALID_POINT ((FIT_STRING_CONVERSION_ERROR)0) +#define FIT_STRING_CONVERSION_ERROR_UNICODE_UNDEFINED_SOURCE_ENCODING ((FIT_STRING_CONVERSION_ERROR)1) +#define FIT_STRING_CONVERSION_ERROR_UNICODE_UNDEFINED_DESTINATION_ENCODING ((FIT_STRING_CONVERSION_ERROR)2) +#define FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_UNIT ((FIT_STRING_CONVERSION_ERROR)3) +#define FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_LEAD_UNIT ((FIT_STRING_CONVERSION_ERROR)4) +#define FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_CONTINUATION_UNIT ((FIT_STRING_CONVERSION_ERROR)5) +#define FIT_STRING_CONVERSION_ERROR_UTF8_NON_CONTINUATION_UNIT ((FIT_STRING_CONVERSION_ERROR)6) +#define FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_1 ((FIT_STRING_CONVERSION_ERROR)7) +#define FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_2 ((FIT_STRING_CONVERSION_ERROR)8) +#define FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_3 ((FIT_STRING_CONVERSION_ERROR)9) +#define FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_4 ((FIT_STRING_CONVERSION_ERROR)10) +#define FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_NUM_UNITS ((FIT_STRING_CONVERSION_ERROR)11) +#define FIT_STRING_CONVERSION_ERROR_UTF8_END_OF_STRING ((FIT_STRING_CONVERSION_ERROR)12) +#define FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_UNIT ((FIT_STRING_CONVERSION_ERROR)13) +#define FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_LEAD_UNIT ((FIT_STRING_CONVERSION_ERROR)14) +#define FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_TAIL_UNIT ((FIT_STRING_CONVERSION_ERROR)15) +#define FIT_STRING_CONVERSION_ERROR_UTF16_NON_TAIL_UNIT ((FIT_STRING_CONVERSION_ERROR)16) +#define FIT_STRING_CONVERSION_ERROR_UTF16_OVERENCODED_POINT_1 ((FIT_STRING_CONVERSION_ERROR)17) +#define FIT_STRING_CONVERSION_ERROR_UTF16_OVERENCODED_POINT_2 ((FIT_STRING_CONVERSION_ERROR)18) +#define FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_NUM_UNITS ((FIT_STRING_CONVERSION_ERROR)19) +#define FIT_STRING_CONVERSION_ERROR_UTF16_END_OF_STRING ((FIT_STRING_CONVERSION_ERROR)20) +#define FIT_STRING_CONVERSION_ERROR_UTF32_INVALID_UNIT ((FIT_STRING_CONVERSION_ERROR)21) +#define FIT_STRING_CONVERSION_ERROR_INVALID FIT_ENUM_INVALID +#define FIT_STRING_CONVERSION_ERROR_COUNT 22 + +// General Unicode. +typedef unsigned long int FIT_LARGE_TYPE; +#define UNICODE_IS_POINT_VALID(POINT) ((((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x00D7FF) || (((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) >= (FIT_LARGE_TYPE)0x00E000)) && (((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x10FFFF)) ? (FIT_TRUE) : (FIT_FALSE)) + +// UTF-8 encoding. +#define UTF8_IS_UNIT_VALID(UNIT) (((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFF) != (FIT_LARGE_TYPE)0xC0) && (((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFF) != (FIT_LARGE_TYPE)0xC1) && (((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFF) <= (FIT_LARGE_TYPE)0xF4)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_UNIT_1UNIT(UNIT) ((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0x80) == (FIT_LARGE_TYPE)0x00) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_UNIT_2UNIT_LEAD(UNIT) ((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xE0) == (FIT_LARGE_TYPE)0xC0) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_UNIT_3UNIT_LEAD(UNIT) ((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xF0) == (FIT_LARGE_TYPE)0xE0) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_UNIT_4UNIT_LEAD(UNIT) ((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xF8) == (FIT_LARGE_TYPE)0xF0) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_UNIT_MULTI_CONT(UNIT) ((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xC0) == (FIT_LARGE_TYPE)0x80) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_POINT_1UNIT(POINT) (((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x00007F)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_POINT_2UNIT(POINT) (((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) >= (FIT_LARGE_TYPE)0x000080) && (((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x0007FF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_POINT_3UNIT(POINT) (((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) >= (FIT_LARGE_TYPE)0x000800) && (((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x00FFFF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_IS_POINT_4UNIT(POINT) (((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) >= (FIT_LARGE_TYPE)0x010000) && (((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x10FFFF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF8_1UNIT_TO_POINT(UNIT) ((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0x7F) << 0)) +#define UTF8_2UNIT_TO_POINT(LEAD,C1) ((((FIT_LARGE_TYPE)(LEAD) & (FIT_LARGE_TYPE)0x1F) << 6) | (((FIT_LARGE_TYPE)(C1) & (FIT_LARGE_TYPE)0x3F) << 0)) +#define UTF8_3UNIT_TO_POINT(LEAD,C1,C2) ((((FIT_LARGE_TYPE)(LEAD) & (FIT_LARGE_TYPE)0x0F) << 12) | (((FIT_LARGE_TYPE)(C1) & (FIT_LARGE_TYPE)0x3F) << 6) | (((FIT_LARGE_TYPE)(C2) & (FIT_LARGE_TYPE)0x3F) << 0)) +#define UTF8_4UNIT_TO_POINT(LEAD,C1,C2,C3) ((((FIT_LARGE_TYPE)(LEAD) & (FIT_LARGE_TYPE)0x07) << 18) | (((FIT_LARGE_TYPE)(C1) & (FIT_LARGE_TYPE)0x3F) << 12) | (((FIT_LARGE_TYPE)(C2) & (FIT_LARGE_TYPE)0x3F) << 6) | (((FIT_LARGE_TYPE)(C3) & (FIT_LARGE_TYPE)0x3F) << 0)) +#define UTF8_POINT_TO_1UNIT(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 0) & (FIT_LARGE_TYPE)0x7F) | (FIT_LARGE_TYPE)0x00) +#define UTF8_POINT_TO_2UNIT_LEAD(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 6) & (FIT_LARGE_TYPE)0x1F) | (FIT_LARGE_TYPE)0xC0) +#define UTF8_POINT_TO_2UNIT_CONT1(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 0) & (FIT_LARGE_TYPE)0x3F) | (FIT_LARGE_TYPE)0x80) +#define UTF8_POINT_TO_3UNIT_LEAD(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 12) & (FIT_LARGE_TYPE)0x0F) | (FIT_LARGE_TYPE)0xE0) +#define UTF8_POINT_TO_3UNIT_CONT1(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 6) & (FIT_LARGE_TYPE)0x3F) | (FIT_LARGE_TYPE)0x80) +#define UTF8_POINT_TO_3UNIT_CONT2(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 0) & (FIT_LARGE_TYPE)0x3F) | (FIT_LARGE_TYPE)0x80) +#define UTF8_POINT_TO_4UNIT_LEAD(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 18) & (FIT_LARGE_TYPE)0x07) | (FIT_LARGE_TYPE)0xF0) +#define UTF8_POINT_TO_4UNIT_CONT1(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 12) & (FIT_LARGE_TYPE)0x3F) | (FIT_LARGE_TYPE)0x80) +#define UTF8_POINT_TO_4UNIT_CONT2(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 6) & (FIT_LARGE_TYPE)0x3F) | (FIT_LARGE_TYPE)0x80) +#define UTF8_POINT_TO_4UNIT_CONT3(POINT) ((((FIT_LARGE_TYPE)(POINT) >> 0) & (FIT_LARGE_TYPE)0x3F) | (FIT_LARGE_TYPE)0x80) + +// UTF-16 encoding. +// Using unicode version 8.0 D91, http://www.unicode.org/versions/Unicode8.0.0/ch03.pdf +// Isolated code units in the range D800..DFFF are ill formed. +// Any UTF 32 code unit > 10FFFF is ill formed. +// This check is already performed by UNICODE_IS_POINT_VALID macro +#define UTF16_IS_UNIT_VALID(UNIT) (UNICODE_IS_POINT_VALID(UNIT)) +#define UTF16_IS_UNIT_1UNIT(UNIT) (((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF)<= (FIT_LARGE_TYPE)0xD7FF) || (((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF)>= (FIT_LARGE_TYPE)0xE000)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF16_IS_UNIT_2UNIT_LEAD(UNIT) (((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF)>= (FIT_LARGE_TYPE)0xD800) && (((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF)<= (FIT_LARGE_TYPE)0xDBFF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF16_IS_UNIT_2UNIT_TAIL(UNIT) (((((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF)>= (FIT_LARGE_TYPE)0xDC00) && (((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF)<= (FIT_LARGE_TYPE)0xDFFF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF16_IS_POINT_1UNIT(POINT) (((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x00FFFF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF16_IS_POINT_2UNIT(POINT) (((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) >= (FIT_LARGE_TYPE)0x010000) && (((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) <= (FIT_LARGE_TYPE)0x10FFFF)) ? (FIT_TRUE) : (FIT_FALSE)) +#define UTF16_1UNIT_TO_POINT(UNIT) ((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0xFFFF) +#define UTF16_2UNIT_TO_POINT(LEAD,TAIL) (((((FIT_LARGE_TYPE)(LEAD) & (FIT_LARGE_TYPE)0xFFFF) - (FIT_LARGE_TYPE)0xD800) << 10) + ((((FIT_LARGE_TYPE)(TAIL) & (FIT_LARGE_TYPE)0xFFFF) - (FIT_LARGE_TYPE)0xDC00) << 0) + (FIT_LARGE_TYPE)0x10000) +#define UTF16_POINT_TO_1UNIT(POINT) ((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0xFFFF) +#define UTF16_POINT_TO_2UNIT_LEAD(POINT) ((((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) - (FIT_LARGE_TYPE)0x10000) >> 10) & (FIT_LARGE_TYPE)0x3FF) + (FIT_LARGE_TYPE)0xD800) +#define UTF16_POINT_TO_2UNIT_TAIL(POINT) ((((((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x1FFFFF) - (FIT_LARGE_TYPE)0x10000) >> 0) & (FIT_LARGE_TYPE)0x3FF) + (FIT_LARGE_TYPE)0xDC00) + +// UTF 32 encoding +// Using unicode version 8.0 D90, http://www.unicode.org/versions/Unicode8.0.0/ch03.pdf +// UTF 32 code units in the range 0000D800..0000DFFF are ill formed. +// Any UTF 32 code unit > 0010FFFF is ill formed. +// This check is already performed by UNICODE_IS_POINT_VALID macro +#define UTF32_IS_UNIT_VALID(UNIT) (UNICODE_IS_POINT_VALID(UNIT)) +#define UTF32_UNIT_TO_POINT(UNIT) ((FIT_LARGE_TYPE)(UNIT) & (FIT_LARGE_TYPE)0x0010FFFF) +#define UTF32_POINT_TO_UNIT(POINT) ((FIT_LARGE_TYPE)(POINT) & (FIT_LARGE_TYPE)0x0010FFFF) + +namespace fit +{ + +/////////////////////////////////////////////////////////////////////// +// Private Classes +/////////////////////////////////////////////////////////////////////// + +class StringConversionException : public RuntimeException +{ +public: + StringConversionException(const FIT_STRING_CONVERSION_ERROR newErrorCode = FIT_STRING_CONVERSION_ERROR_INVALID) + : RuntimeException(std::string("")), + errorCode(newErrorCode) + { + } + +private: + FIT_STRING_CONVERSION_ERROR errorCode; +}; + +/////////////////////////////////////////////////////////////////////// +// Private Functions +/////////////////////////////////////////////////////////////////////// + +template +FIT_BOOL ConvertStringEncoding(STRING_TYPE_DST& strDst, const FIT_UNICODE_ENCODING dstEncoding, const STRING_TYPE_SRC& strSrc, const FIT_UNICODE_ENCODING srcEncoding) +{ + STRING_TYPE_DST convertedStr; + + for (unsigned long int i = 0; i < strSrc.size(); ++i) + { + try + { + FIT_LARGE_TYPE codePoint = 0; + + // Decode the source. + switch (srcEncoding) + { + case FIT_UNICODE_ENCODING_UTF8: + { + if (!UTF8_IS_UNIT_VALID(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_UNIT); + + unsigned long int numUnits = 0; + + if (UTF8_IS_UNIT_1UNIT(strSrc[i])) + numUnits = 1; + else if (UTF8_IS_UNIT_2UNIT_LEAD(strSrc[i])) + numUnits = 2; + else if (UTF8_IS_UNIT_3UNIT_LEAD(strSrc[i])) + numUnits = 3; + else if (UTF8_IS_UNIT_4UNIT_LEAD(strSrc[i])) + numUnits = 4; + else + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_LEAD_UNIT); + + unsigned long int numContUnits = numUnits - 1; + + while (numContUnits--) + { + if ((++i) >= strSrc.size()) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_END_OF_STRING); + + if (!UTF8_IS_UNIT_MULTI_CONT(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_NON_CONTINUATION_UNIT); + + if (!UTF8_IS_UNIT_VALID(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_CONTINUATION_UNIT); + } + + switch (numUnits) + { + case 1: + codePoint = UTF8_1UNIT_TO_POINT(strSrc[i]); + if (!UTF8_IS_POINT_1UNIT(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_1); + break; + case 2: + codePoint = UTF8_2UNIT_TO_POINT(strSrc[i-1], strSrc[i]); + if (!UTF8_IS_POINT_2UNIT(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_2); + break; + case 3: + codePoint = UTF8_3UNIT_TO_POINT(strSrc[i-2], strSrc[i-1], strSrc[i]); + if (!UTF8_IS_POINT_3UNIT(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_3); + break; + case 4: + codePoint = UTF8_4UNIT_TO_POINT(strSrc[i-3], strSrc[i-2], strSrc[i-1], strSrc[i]); + if (!UTF8_IS_POINT_4UNIT(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_OVERENCODED_POINT_4); + break; + } + } + break; + + case FIT_UNICODE_ENCODING_UTF16: + { + if (!UTF16_IS_UNIT_VALID(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_UNIT); + + if (UTF16_IS_UNIT_1UNIT(strSrc[i])) + { + codePoint = static_cast(UTF16_1UNIT_TO_POINT(strSrc[i])); + + if (!UTF16_IS_POINT_1UNIT(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_OVERENCODED_POINT_1); + } + else if (UTF16_IS_UNIT_2UNIT_LEAD(strSrc[i])) + { + if ((++i) >= strSrc.size()) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_END_OF_STRING); + + if (!UTF16_IS_UNIT_2UNIT_TAIL(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_NON_TAIL_UNIT); + + if (!UTF16_IS_UNIT_VALID(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_TAIL_UNIT); + + codePoint = static_cast(UTF16_2UNIT_TO_POINT(strSrc[i-1], strSrc[i])); + + if (!UTF16_IS_POINT_2UNIT(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_OVERENCODED_POINT_2); + } + else + { + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_LEAD_UNIT); + } + } + break; + + case FIT_UNICODE_ENCODING_UTF32: + { + if (!UTF32_IS_UNIT_VALID(strSrc[i])) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF32_INVALID_UNIT); + + codePoint = static_cast(UTF32_UNIT_TO_POINT(strSrc[i])); + } + break; + + default: + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UNICODE_UNDEFINED_SOURCE_ENCODING); + } + + // Check that the code point is valid. + if (!UNICODE_IS_POINT_VALID(codePoint)) + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UNICODE_INVALID_POINT); + + // Encode the destination. + switch (dstEncoding) + { + case FIT_UNICODE_ENCODING_UTF8: + if (UTF8_IS_POINT_1UNIT(codePoint)) + { + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_1UNIT(codePoint)); + } + else if (UTF8_IS_POINT_2UNIT(codePoint)) + { + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_2UNIT_LEAD(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_2UNIT_CONT1(codePoint)); + } + else if (UTF8_IS_POINT_3UNIT(codePoint)) + { + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_3UNIT_LEAD(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_3UNIT_CONT1(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_3UNIT_CONT2(codePoint)); + } + else if (UTF8_IS_POINT_4UNIT(codePoint)) + { + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_4UNIT_LEAD(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_4UNIT_CONT1(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_4UNIT_CONT2(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF8_POINT_TO_4UNIT_CONT3(codePoint)); + } + else + { + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF8_INVALID_NUM_UNITS); + } + break; + + case FIT_UNICODE_ENCODING_UTF16: + if (UTF16_IS_POINT_1UNIT(codePoint)) + { + convertedStr.push_back((CHAR_TYPE_DST) UTF16_POINT_TO_1UNIT(codePoint)); + } + else if (UTF16_IS_POINT_2UNIT(codePoint)) + { + convertedStr.push_back((CHAR_TYPE_DST) UTF16_POINT_TO_2UNIT_LEAD(codePoint)); + convertedStr.push_back((CHAR_TYPE_DST) UTF16_POINT_TO_2UNIT_TAIL(codePoint)); + } + else + { + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UTF16_INVALID_NUM_UNITS); + } + break; + + case FIT_UNICODE_ENCODING_UTF32: + convertedStr.push_back((CHAR_TYPE_DST) UTF32_POINT_TO_UNIT(codePoint)); + break; + + default: + throw StringConversionException(FIT_STRING_CONVERSION_ERROR_UNICODE_UNDEFINED_DESTINATION_ENCODING); + } + + } // end try + catch (const StringConversionException&) + { + continue; // Go to the next character. + } + } + + strDst = convertedStr; + return FIT_TRUE; +} + + +/////////////////////////////////////////////////////////////////////// +// Public Functions +/////////////////////////////////////////////////////////////////////// + +Unicode::UTF8_STRING Unicode::Encode_BaseToUTF8(const FIT_WSTRING& strSrc) +{ + Unicode::UTF8_STRING strDst; + if (ConvertStringEncoding(strDst, FIT_UNICODE_ENCODING_UTF8, strSrc, INTERNAL_UNICODE_ENCODING)) + return strDst; + else + return Unicode::UTF8_STRING(); +} + +FIT_WSTRING Unicode::Encode_UTF8ToBase(const Unicode::UTF8_STRING& strSrc) +{ + FIT_WSTRING strDst; + if (ConvertStringEncoding(strDst, INTERNAL_UNICODE_ENCODING, strSrc, FIT_UNICODE_ENCODING_UTF8)) + return strDst; + else + return FIT_WSTRING_INVALID; +} + +Unicode::UTF8_STRING Unicode::Copy_StdToUTF8(const std::string& strSrc) +{ +#if 0 + Unicode::UTF8_STRING strDst(static_cast(strSrc.size()), 0); + + for (Unicode::UTF8_STRING::size_type i = 0; i < strDst.size(); i++) + strDst[i] = static_cast(strSrc[i]); + + return strDst; +#endif + + return strSrc; // Input type is typedef'd to be the same as output - this shortcut is valid. +} + +std::string Unicode::Copy_UTF8ToStd(const Unicode::UTF8_STRING& strSrc) +{ +#if 0 + string strDst(static_cast(strSrc.size()), 0); + + for (std::string::size_type i = 0; i < strDst.size(); i++) + strDst[i] = static_cast(strSrc[i]); + + return strDst; +#endif + + return strSrc; // Input type is typedef'd to be the same as output - this shortcut is valid. +} + +} // namespace fit diff --git a/fit_unicode.hpp b/fit_unicode.hpp new file mode 100644 index 0000000..e4e38c1 --- /dev/null +++ b/fit_unicode.hpp @@ -0,0 +1,43 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_UNICODE_HPP) +#define FIT_UNICODE_HPP + +#include +#include +#include "fit.hpp" + +namespace fit +{ + +class Unicode +{ +public: + typedef std::string UTF8_STRING; // UTF-8 encoded strings used for file/message input and output. + typedef std::fstream UTF8_FSTREAM; + typedef std::ofstream UTF8_OFSTREAM; + typedef std::ifstream UTF8_IFSTREAM; + typedef std::stringstream UTF8_SSTREAM; + typedef std::ostringstream UTF8_OSSTREAM; + typedef std::istringstream UTF8_ISSTREAM; + +public: + static Unicode::UTF8_STRING Encode_BaseToUTF8(const FIT_WSTRING& strSrc); + static FIT_WSTRING Encode_UTF8ToBase(const Unicode::UTF8_STRING& strSrc); + static Unicode::UTF8_STRING Copy_StdToUTF8(const std::string& strSrc); + static std::string Copy_UTF8ToStd(const Unicode::UTF8_STRING& strSrc); +}; + +} // namespace fit + +#endif // !defined(FIT_UNICODE_HPP) diff --git a/fit_user_profile_mesg.hpp b/fit_user_profile_mesg.hpp new file mode 100644 index 0000000..03711ba --- /dev/null +++ b/fit_user_profile_mesg.hpp @@ -0,0 +1,1006 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_USER_PROFILE_MESG_HPP) +#define FIT_USER_PROFILE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class UserProfileMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 FriendlyName = 0; + static const FIT_UINT8 Gender = 1; + static const FIT_UINT8 Age = 2; + static const FIT_UINT8 Height = 3; + static const FIT_UINT8 Weight = 4; + static const FIT_UINT8 Language = 5; + static const FIT_UINT8 ElevSetting = 6; + static const FIT_UINT8 WeightSetting = 7; + static const FIT_UINT8 RestingHeartRate = 8; + static const FIT_UINT8 DefaultMaxRunningHeartRate = 9; + static const FIT_UINT8 DefaultMaxBikingHeartRate = 10; + static const FIT_UINT8 DefaultMaxHeartRate = 11; + static const FIT_UINT8 HrSetting = 12; + static const FIT_UINT8 SpeedSetting = 13; + static const FIT_UINT8 DistSetting = 14; + static const FIT_UINT8 PowerSetting = 16; + static const FIT_UINT8 ActivityClass = 17; + static const FIT_UINT8 PositionSetting = 18; + static const FIT_UINT8 TemperatureSetting = 21; + static const FIT_UINT8 LocalId = 22; + static const FIT_UINT8 GlobalId = 23; + static const FIT_UINT8 WakeTime = 28; + static const FIT_UINT8 SleepTime = 29; + static const FIT_UINT8 HeightSetting = 30; + static const FIT_UINT8 UserRunningStepLength = 31; + static const FIT_UINT8 UserWalkingStepLength = 32; + static const FIT_UINT8 DepthSetting = 47; + static const FIT_UINT8 DiveCount = 49; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + UserProfileMesg(void) : Mesg(Profile::MESG_USER_PROFILE) + { + } + + UserProfileMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of friendly_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFriendlyNameValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns friendly_name field + // Comment: Used for Morning Report greeting + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetFriendlyName(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set friendly_name field + // Comment: Used for Morning Report greeting + /////////////////////////////////////////////////////////////////////// + void SetFriendlyName(FIT_WSTRING friendlyName) + { + SetFieldSTRINGValue(0, friendlyName, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of gender field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGenderValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns gender field + /////////////////////////////////////////////////////////////////////// + FIT_GENDER GetGender(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set gender field + /////////////////////////////////////////////////////////////////////// + void SetGender(FIT_GENDER gender) + { + SetFieldENUMValue(1, gender, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of age field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAgeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns age field + // Units: years + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetAge(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set age field + // Units: years + /////////////////////////////////////////////////////////////////////// + void SetAge(FIT_UINT8 age) + { + SetFieldUINT8Value(2, age, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of height field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeightValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns height field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetHeight(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set height field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetHeight(FIT_FLOAT32 height) + { + SetFieldFLOAT32Value(3, height, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weight field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeightValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetWeight(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetWeight(FIT_FLOAT32 weight) + { + SetFieldFLOAT32Value(4, weight, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of language field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLanguageValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns language field + /////////////////////////////////////////////////////////////////////// + FIT_LANGUAGE GetLanguage(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set language field + /////////////////////////////////////////////////////////////////////// + void SetLanguage(FIT_LANGUAGE language) + { + SetFieldENUMValue(5, language, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of elev_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsElevSettingValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns elev_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetElevSetting(void) const + { + return GetFieldENUMValue(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set elev_setting field + /////////////////////////////////////////////////////////////////////// + void SetElevSetting(FIT_DISPLAY_MEASURE elevSetting) + { + SetFieldENUMValue(6, elevSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weight_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeightSettingValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weight_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetWeightSetting(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weight_setting field + /////////////////////////////////////////////////////////////////////// + void SetWeightSetting(FIT_DISPLAY_MEASURE weightSetting) + { + SetFieldENUMValue(7, weightSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of resting_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRestingHeartRateValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns resting_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRestingHeartRate(void) const + { + return GetFieldUINT8Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set resting_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetRestingHeartRate(FIT_UINT8 restingHeartRate) + { + SetFieldUINT8Value(8, restingHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of default_max_running_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDefaultMaxRunningHeartRateValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns default_max_running_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDefaultMaxRunningHeartRate(void) const + { + return GetFieldUINT8Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set default_max_running_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetDefaultMaxRunningHeartRate(FIT_UINT8 defaultMaxRunningHeartRate) + { + SetFieldUINT8Value(9, defaultMaxRunningHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of default_max_biking_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDefaultMaxBikingHeartRateValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns default_max_biking_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDefaultMaxBikingHeartRate(void) const + { + return GetFieldUINT8Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set default_max_biking_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetDefaultMaxBikingHeartRate(FIT_UINT8 defaultMaxBikingHeartRate) + { + SetFieldUINT8Value(10, defaultMaxBikingHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of default_max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDefaultMaxHeartRateValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns default_max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetDefaultMaxHeartRate(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set default_max_heart_rate field + // Units: bpm + /////////////////////////////////////////////////////////////////////// + void SetDefaultMaxHeartRate(FIT_UINT8 defaultMaxHeartRate) + { + SetFieldUINT8Value(11, defaultMaxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrSettingValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hr_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_HEART GetHrSetting(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_setting field + /////////////////////////////////////////////////////////////////////// + void SetHrSetting(FIT_DISPLAY_HEART hrSetting) + { + SetFieldENUMValue(12, hrSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of speed_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSpeedSettingValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns speed_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetSpeedSetting(void) const + { + return GetFieldENUMValue(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set speed_setting field + /////////////////////////////////////////////////////////////////////// + void SetSpeedSetting(FIT_DISPLAY_MEASURE speedSetting) + { + SetFieldENUMValue(13, speedSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dist_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDistSettingValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dist_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetDistSetting(void) const + { + return GetFieldENUMValue(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dist_setting field + /////////////////////////////////////////////////////////////////////// + void SetDistSetting(FIT_DISPLAY_MEASURE distSetting) + { + SetFieldENUMValue(14, distSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of power_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPowerSettingValid() const + { + const Field* field = GetField(16); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns power_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_POWER GetPowerSetting(void) const + { + return GetFieldENUMValue(16, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set power_setting field + /////////////////////////////////////////////////////////////////////// + void SetPowerSetting(FIT_DISPLAY_POWER powerSetting) + { + SetFieldENUMValue(16, powerSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of activity_class field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActivityClassValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns activity_class field + /////////////////////////////////////////////////////////////////////// + FIT_ACTIVITY_CLASS GetActivityClass(void) const + { + return GetFieldENUMValue(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set activity_class field + /////////////////////////////////////////////////////////////////////// + void SetActivityClass(FIT_ACTIVITY_CLASS activityClass) + { + SetFieldENUMValue(17, activityClass, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of position_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPositionSettingValid() const + { + const Field* field = GetField(18); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns position_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_POSITION GetPositionSetting(void) const + { + return GetFieldENUMValue(18, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set position_setting field + /////////////////////////////////////////////////////////////////////// + void SetPositionSetting(FIT_DISPLAY_POSITION positionSetting) + { + SetFieldENUMValue(18, positionSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureSettingValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetTemperatureSetting(void) const + { + return GetFieldENUMValue(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature_setting field + /////////////////////////////////////////////////////////////////////// + void SetTemperatureSetting(FIT_DISPLAY_MEASURE temperatureSetting) + { + SetFieldENUMValue(21, temperatureSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of local_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocalIdValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns local_id field + /////////////////////////////////////////////////////////////////////// + FIT_USER_LOCAL_ID GetLocalId(void) const + { + return GetFieldUINT16Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set local_id field + /////////////////////////////////////////////////////////////////////// + void SetLocalId(FIT_USER_LOCAL_ID localId) + { + SetFieldUINT16Value(22, localId, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Returns number of global_id + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetNumGlobalId(void) const + { + return GetFieldNumValues(23, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of global_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsGlobalIdValid(FIT_UINT8 index) const + { + const Field* field = GetField(23); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(index); + } + + /////////////////////////////////////////////////////////////////////// + // Returns global_id field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetGlobalId(FIT_UINT8 index) const + { + return GetFieldBYTEValue(23, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set global_id field + /////////////////////////////////////////////////////////////////////// + void SetGlobalId(FIT_UINT8 index, FIT_BYTE globalId) + { + SetFieldBYTEValue(23, globalId, index, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wake_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWakeTimeValid() const + { + const Field* field = GetField(28); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wake_time field + // Comment: Typical wake time + /////////////////////////////////////////////////////////////////////// + FIT_LOCALTIME_INTO_DAY GetWakeTime(void) const + { + return GetFieldUINT32Value(28, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wake_time field + // Comment: Typical wake time + /////////////////////////////////////////////////////////////////////// + void SetWakeTime(FIT_LOCALTIME_INTO_DAY wakeTime) + { + SetFieldUINT32Value(28, wakeTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sleep_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSleepTimeValid() const + { + const Field* field = GetField(29); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sleep_time field + // Comment: Typical bed time + /////////////////////////////////////////////////////////////////////// + FIT_LOCALTIME_INTO_DAY GetSleepTime(void) const + { + return GetFieldUINT32Value(29, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sleep_time field + // Comment: Typical bed time + /////////////////////////////////////////////////////////////////////// + void SetSleepTime(FIT_LOCALTIME_INTO_DAY sleepTime) + { + SetFieldUINT32Value(29, sleepTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of height_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHeightSettingValid() const + { + const Field* field = GetField(30); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns height_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetHeightSetting(void) const + { + return GetFieldENUMValue(30, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set height_setting field + /////////////////////////////////////////////////////////////////////// + void SetHeightSetting(FIT_DISPLAY_MEASURE heightSetting) + { + SetFieldENUMValue(30, heightSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of user_running_step_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUserRunningStepLengthValid() const + { + const Field* field = GetField(31); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns user_running_step_length field + // Units: m + // Comment: User defined running step length set to 0 for auto length + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetUserRunningStepLength(void) const + { + return GetFieldFLOAT32Value(31, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set user_running_step_length field + // Units: m + // Comment: User defined running step length set to 0 for auto length + /////////////////////////////////////////////////////////////////////// + void SetUserRunningStepLength(FIT_FLOAT32 userRunningStepLength) + { + SetFieldFLOAT32Value(31, userRunningStepLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of user_walking_step_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUserWalkingStepLengthValid() const + { + const Field* field = GetField(32); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns user_walking_step_length field + // Units: m + // Comment: User defined walking step length set to 0 for auto length + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetUserWalkingStepLength(void) const + { + return GetFieldFLOAT32Value(32, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set user_walking_step_length field + // Units: m + // Comment: User defined walking step length set to 0 for auto length + /////////////////////////////////////////////////////////////////////// + void SetUserWalkingStepLength(FIT_FLOAT32 userWalkingStepLength) + { + SetFieldFLOAT32Value(32, userWalkingStepLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of depth_setting field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDepthSettingValid() const + { + const Field* field = GetField(47); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns depth_setting field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetDepthSetting(void) const + { + return GetFieldENUMValue(47, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set depth_setting field + /////////////////////////////////////////////////////////////////////// + void SetDepthSetting(FIT_DISPLAY_MEASURE depthSetting) + { + SetFieldENUMValue(47, depthSetting, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of dive_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDiveCountValid() const + { + const Field* field = GetField(49); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns dive_count field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDiveCount(void) const + { + return GetFieldUINT32Value(49, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set dive_count field + /////////////////////////////////////////////////////////////////////// + void SetDiveCount(FIT_UINT32 diveCount) + { + SetFieldUINT32Value(49, diveCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_USER_PROFILE_MESG_HPP) diff --git a/fit_user_profile_mesg_listener.hpp b/fit_user_profile_mesg_listener.hpp new file mode 100644 index 0000000..1c136de --- /dev/null +++ b/fit_user_profile_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_USER_PROFILE_MESG_LISTENER_HPP) +#define FIT_USER_PROFILE_MESG_LISTENER_HPP + +#include "fit_user_profile_mesg.hpp" + +namespace fit +{ + +class UserProfileMesgListener +{ +public: + virtual ~UserProfileMesgListener() {} + virtual void OnMesg(UserProfileMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_USER_PROFILE_MESG_LISTENER_HPP) diff --git a/fit_video_clip_mesg.hpp b/fit_video_clip_mesg.hpp new file mode 100644 index 0000000..eccf075 --- /dev/null +++ b/fit_video_clip_mesg.hpp @@ -0,0 +1,274 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_CLIP_MESG_HPP) +#define FIT_VIDEO_CLIP_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class VideoClipMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 ClipNumber = 0; + static const FIT_UINT8 StartTimestamp = 1; + static const FIT_UINT8 StartTimestampMs = 2; + static const FIT_UINT8 EndTimestamp = 3; + static const FIT_UINT8 EndTimestampMs = 4; + static const FIT_UINT8 ClipStart = 6; + static const FIT_UINT8 ClipEnd = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + VideoClipMesg(void) : Mesg(Profile::MESG_VIDEO_CLIP) + { + } + + VideoClipMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of clip_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClipNumberValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns clip_number field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetClipNumber(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set clip_number field + /////////////////////////////////////////////////////////////////////// + void SetClipNumber(FIT_UINT16 clipNumber) + { + SetFieldUINT16Value(0, clipNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimestampValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetStartTimestamp(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_timestamp field + /////////////////////////////////////////////////////////////////////// + void SetStartTimestamp(FIT_DATE_TIME startTimestamp) + { + SetFieldUINT32Value(1, startTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of start_timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsStartTimestampMsValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns start_timestamp_ms field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetStartTimestampMs(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set start_timestamp_ms field + /////////////////////////////////////////////////////////////////////// + void SetStartTimestampMs(FIT_UINT16 startTimestampMs) + { + SetFieldUINT16Value(2, startTimestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndTimestampValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetEndTimestamp(void) const + { + return GetFieldUINT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_timestamp field + /////////////////////////////////////////////////////////////////////// + void SetEndTimestamp(FIT_DATE_TIME endTimestamp) + { + SetFieldUINT32Value(3, endTimestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of end_timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEndTimestampMsValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns end_timestamp_ms field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetEndTimestampMs(void) const + { + return GetFieldUINT16Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set end_timestamp_ms field + /////////////////////////////////////////////////////////////////////// + void SetEndTimestampMs(FIT_UINT16 endTimestampMs) + { + SetFieldUINT16Value(4, endTimestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of clip_start field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClipStartValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns clip_start field + // Units: ms + // Comment: Start of clip in video time + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetClipStart(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set clip_start field + // Units: ms + // Comment: Start of clip in video time + /////////////////////////////////////////////////////////////////////// + void SetClipStart(FIT_UINT32 clipStart) + { + SetFieldUINT32Value(6, clipStart, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of clip_end field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsClipEndValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns clip_end field + // Units: ms + // Comment: End of clip in video time + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetClipEnd(void) const + { + return GetFieldUINT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set clip_end field + // Units: ms + // Comment: End of clip in video time + /////////////////////////////////////////////////////////////////////// + void SetClipEnd(FIT_UINT32 clipEnd) + { + SetFieldUINT32Value(7, clipEnd, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_CLIP_MESG_HPP) diff --git a/fit_video_clip_mesg_listener.hpp b/fit_video_clip_mesg_listener.hpp new file mode 100644 index 0000000..0ec8b0e --- /dev/null +++ b/fit_video_clip_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_CLIP_MESG_LISTENER_HPP) +#define FIT_VIDEO_CLIP_MESG_LISTENER_HPP + +#include "fit_video_clip_mesg.hpp" + +namespace fit +{ + +class VideoClipMesgListener +{ +public: + virtual ~VideoClipMesgListener() {} + virtual void OnMesg(VideoClipMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_CLIP_MESG_LISTENER_HPP) diff --git a/fit_video_description_mesg.hpp b/fit_video_description_mesg.hpp new file mode 100644 index 0000000..0745ce2 --- /dev/null +++ b/fit_video_description_mesg.hpp @@ -0,0 +1,142 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_DESCRIPTION_MESG_HPP) +#define FIT_VIDEO_DESCRIPTION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class VideoDescriptionMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 MessageCount = 0; + static const FIT_UINT8 Text = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + VideoDescriptionMesg(void) : Mesg(Profile::MESG_VIDEO_DESCRIPTION) + { + } + + VideoDescriptionMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + // Comment: Long descriptions will be split into multiple parts + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + // Comment: Long descriptions will be split into multiple parts + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageCountValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_count field + // Comment: Total number of description parts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMessageCount(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_count field + // Comment: Total number of description parts + /////////////////////////////////////////////////////////////////////// + void SetMessageCount(FIT_UINT16 messageCount) + { + SetFieldUINT16Value(0, messageCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of text field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTextValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns text field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetText(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set text field + /////////////////////////////////////////////////////////////////////// + void SetText(FIT_WSTRING text) + { + SetFieldSTRINGValue(1, text, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_DESCRIPTION_MESG_HPP) diff --git a/fit_video_description_mesg_listener.hpp b/fit_video_description_mesg_listener.hpp new file mode 100644 index 0000000..72c0b51 --- /dev/null +++ b/fit_video_description_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_DESCRIPTION_MESG_LISTENER_HPP) +#define FIT_VIDEO_DESCRIPTION_MESG_LISTENER_HPP + +#include "fit_video_description_mesg.hpp" + +namespace fit +{ + +class VideoDescriptionMesgListener +{ +public: + virtual ~VideoDescriptionMesgListener() {} + virtual void OnMesg(VideoDescriptionMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_DESCRIPTION_MESG_LISTENER_HPP) diff --git a/fit_video_frame_mesg.hpp b/fit_video_frame_mesg.hpp new file mode 100644 index 0000000..8abc828 --- /dev/null +++ b/fit_video_frame_mesg.hpp @@ -0,0 +1,148 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_FRAME_MESG_HPP) +#define FIT_VIDEO_FRAME_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class VideoFrameMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 TimestampMs = 0; + static const FIT_UINT8 FrameNumber = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + VideoFrameMesg(void) : Mesg(Profile::MESG_VIDEO_FRAME) + { + } + + VideoFrameMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + // Comment: Whole second part of the timestamp + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp_ms field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampMsValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetTimestampMs(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp_ms field + // Units: ms + // Comment: Millisecond part of the timestamp. + /////////////////////////////////////////////////////////////////////// + void SetTimestampMs(FIT_UINT16 timestampMs) + { + SetFieldUINT16Value(0, timestampMs, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of frame_number field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFrameNumberValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns frame_number field + // Comment: Number of the frame that the timestamp and timestamp_ms correlate to + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetFrameNumber(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set frame_number field + // Comment: Number of the frame that the timestamp and timestamp_ms correlate to + /////////////////////////////////////////////////////////////////////// + void SetFrameNumber(FIT_UINT32 frameNumber) + { + SetFieldUINT32Value(1, frameNumber, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_FRAME_MESG_HPP) diff --git a/fit_video_frame_mesg_listener.hpp b/fit_video_frame_mesg_listener.hpp new file mode 100644 index 0000000..559cee8 --- /dev/null +++ b/fit_video_frame_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_FRAME_MESG_LISTENER_HPP) +#define FIT_VIDEO_FRAME_MESG_LISTENER_HPP + +#include "fit_video_frame_mesg.hpp" + +namespace fit +{ + +class VideoFrameMesgListener +{ +public: + virtual ~VideoFrameMesgListener() {} + virtual void OnMesg(VideoFrameMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_FRAME_MESG_LISTENER_HPP) diff --git a/fit_video_mesg.hpp b/fit_video_mesg.hpp new file mode 100644 index 0000000..129f583 --- /dev/null +++ b/fit_video_mesg.hpp @@ -0,0 +1,142 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_MESG_HPP) +#define FIT_VIDEO_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class VideoMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Url = 0; + static const FIT_UINT8 HostingProvider = 1; + static const FIT_UINT8 Duration = 2; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + VideoMesg(void) : Mesg(Profile::MESG_VIDEO) + { + } + + VideoMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of url field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUrlValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns url field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetUrl(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set url field + /////////////////////////////////////////////////////////////////////// + void SetUrl(FIT_WSTRING url) + { + SetFieldSTRINGValue(0, url, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hosting_provider field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHostingProviderValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hosting_provider field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetHostingProvider(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hosting_provider field + /////////////////////////////////////////////////////////////////////// + void SetHostingProvider(FIT_WSTRING hostingProvider) + { + SetFieldSTRINGValue(1, hostingProvider, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns duration field + // Units: ms + // Comment: Playback time of video + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDuration(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration field + // Units: ms + // Comment: Playback time of video + /////////////////////////////////////////////////////////////////////// + void SetDuration(FIT_UINT32 duration) + { + SetFieldUINT32Value(2, duration, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_MESG_HPP) diff --git a/fit_video_mesg_listener.hpp b/fit_video_mesg_listener.hpp new file mode 100644 index 0000000..16286be --- /dev/null +++ b/fit_video_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_MESG_LISTENER_HPP) +#define FIT_VIDEO_MESG_LISTENER_HPP + +#include "fit_video_mesg.hpp" + +namespace fit +{ + +class VideoMesgListener +{ +public: + virtual ~VideoMesgListener() {} + virtual void OnMesg(VideoMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_MESG_LISTENER_HPP) diff --git a/fit_video_title_mesg.hpp b/fit_video_title_mesg.hpp new file mode 100644 index 0000000..acb0aa0 --- /dev/null +++ b/fit_video_title_mesg.hpp @@ -0,0 +1,142 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_TITLE_MESG_HPP) +#define FIT_VIDEO_TITLE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class VideoTitleMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 MessageCount = 0; + static const FIT_UINT8 Text = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + VideoTitleMesg(void) : Mesg(Profile::MESG_VIDEO_TITLE) + { + } + + VideoTitleMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + // Comment: Long titles will be split into multiple parts + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + // Comment: Long titles will be split into multiple parts + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_count field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageCountValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_count field + // Comment: Total number of title parts + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetMessageCount(void) const + { + return GetFieldUINT16Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_count field + // Comment: Total number of title parts + /////////////////////////////////////////////////////////////////////// + void SetMessageCount(FIT_UINT16 messageCount) + { + SetFieldUINT16Value(0, messageCount, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of text field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTextValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns text field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetText(void) const + { + return GetFieldSTRINGValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set text field + /////////////////////////////////////////////////////////////////////// + void SetText(FIT_WSTRING text) + { + SetFieldSTRINGValue(1, text, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_TITLE_MESG_HPP) diff --git a/fit_video_title_mesg_listener.hpp b/fit_video_title_mesg_listener.hpp new file mode 100644 index 0000000..b7cdab0 --- /dev/null +++ b/fit_video_title_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_VIDEO_TITLE_MESG_LISTENER_HPP) +#define FIT_VIDEO_TITLE_MESG_LISTENER_HPP + +#include "fit_video_title_mesg.hpp" + +namespace fit +{ + +class VideoTitleMesgListener +{ +public: + virtual ~VideoTitleMesgListener() {} + virtual void OnMesg(VideoTitleMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_VIDEO_TITLE_MESG_LISTENER_HPP) diff --git a/fit_watchface_settings_mesg.hpp b/fit_watchface_settings_mesg.hpp new file mode 100644 index 0000000..ffea624 --- /dev/null +++ b/fit_watchface_settings_mesg.hpp @@ -0,0 +1,212 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WATCHFACE_SETTINGS_MESG_HPP) +#define FIT_WATCHFACE_SETTINGS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WatchfaceSettingsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Mode = 0; + static const FIT_UINT8 Layout = 1; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WatchfaceSettingsMesg(void) : Mesg(Profile::MESG_WATCHFACE_SETTINGS) + { + } + + WatchfaceSettingsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of mode field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsModeValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns mode field + /////////////////////////////////////////////////////////////////////// + FIT_WATCHFACE_MODE GetMode(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set mode field + /////////////////////////////////////////////////////////////////////// + void SetMode(FIT_WATCHFACE_MODE mode) + { + SetFieldENUMValue(0, mode, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of layout field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLayoutValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns layout field + /////////////////////////////////////////////////////////////////////// + FIT_BYTE GetLayout(void) const + { + return GetFieldBYTEValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set layout field + /////////////////////////////////////////////////////////////////////// + void SetLayout(FIT_BYTE layout) + { + SetFieldBYTEValue(1, layout, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of digital_layout field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDigitalLayoutValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_DIGITAL_LAYOUT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_DIGITAL_LAYOUT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns digital_layout field + /////////////////////////////////////////////////////////////////////// + FIT_DIGITAL_WATCHFACE_LAYOUT GetDigitalLayout(void) const + { + return GetFieldENUMValue(1, 0, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_DIGITAL_LAYOUT); + } + + /////////////////////////////////////////////////////////////////////// + // Set digital_layout field + /////////////////////////////////////////////////////////////////////// + void SetDigitalLayout(FIT_DIGITAL_WATCHFACE_LAYOUT digitalLayout) + { + SetFieldENUMValue(1, digitalLayout, 0, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_DIGITAL_LAYOUT); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of analog_layout field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsAnalogLayoutValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_ANALOG_LAYOUT ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_ANALOG_LAYOUT); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns analog_layout field + /////////////////////////////////////////////////////////////////////// + FIT_ANALOG_WATCHFACE_LAYOUT GetAnalogLayout(void) const + { + return GetFieldENUMValue(1, 0, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_ANALOG_LAYOUT); + } + + /////////////////////////////////////////////////////////////////////// + // Set analog_layout field + /////////////////////////////////////////////////////////////////////// + void SetAnalogLayout(FIT_ANALOG_WATCHFACE_LAYOUT analogLayout) + { + SetFieldENUMValue(1, analogLayout, 0, (FIT_UINT16) Profile::WATCHFACE_SETTINGS_MESG_LAYOUT_FIELD_ANALOG_LAYOUT); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WATCHFACE_SETTINGS_MESG_HPP) diff --git a/fit_watchface_settings_mesg_listener.hpp b/fit_watchface_settings_mesg_listener.hpp new file mode 100644 index 0000000..042315f --- /dev/null +++ b/fit_watchface_settings_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WATCHFACE_SETTINGS_MESG_LISTENER_HPP) +#define FIT_WATCHFACE_SETTINGS_MESG_LISTENER_HPP + +#include "fit_watchface_settings_mesg.hpp" + +namespace fit +{ + +class WatchfaceSettingsMesgListener +{ +public: + virtual ~WatchfaceSettingsMesgListener() {} + virtual void OnMesg(WatchfaceSettingsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WATCHFACE_SETTINGS_MESG_LISTENER_HPP) diff --git a/fit_weather_alert_mesg.hpp b/fit_weather_alert_mesg.hpp new file mode 100644 index 0000000..aa2db99 --- /dev/null +++ b/fit_weather_alert_mesg.hpp @@ -0,0 +1,244 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WEATHER_ALERT_MESG_HPP) +#define FIT_WEATHER_ALERT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WeatherAlertMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 ReportId = 0; + static const FIT_UINT8 IssueTime = 1; + static const FIT_UINT8 ExpireTime = 2; + static const FIT_UINT8 Severity = 3; + static const FIT_UINT8 Type = 4; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WeatherAlertMesg(void) : Mesg(Profile::MESG_WEATHER_ALERT) + { + } + + WeatherAlertMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of report_id field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsReportIdValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns report_id field + // Comment: Unique identifier from GCS report ID string, length is 12 + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetReportId(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set report_id field + // Comment: Unique identifier from GCS report ID string, length is 12 + /////////////////////////////////////////////////////////////////////// + void SetReportId(FIT_WSTRING reportId) + { + SetFieldSTRINGValue(0, reportId, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of issue_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIssueTimeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns issue_time field + // Comment: Time alert was issued + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetIssueTime(void) const + { + return GetFieldUINT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set issue_time field + // Comment: Time alert was issued + /////////////////////////////////////////////////////////////////////// + void SetIssueTime(FIT_DATE_TIME issueTime) + { + SetFieldUINT32Value(1, issueTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of expire_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsExpireTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns expire_time field + // Comment: Time alert expires + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetExpireTime(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set expire_time field + // Comment: Time alert expires + /////////////////////////////////////////////////////////////////////// + void SetExpireTime(FIT_DATE_TIME expireTime) + { + SetFieldUINT32Value(2, expireTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of severity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSeverityValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns severity field + // Comment: Warning, Watch, Advisory, Statement + /////////////////////////////////////////////////////////////////////// + FIT_WEATHER_SEVERITY GetSeverity(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set severity field + // Comment: Warning, Watch, Advisory, Statement + /////////////////////////////////////////////////////////////////////// + void SetSeverity(FIT_WEATHER_SEVERITY severity) + { + SetFieldENUMValue(3, severity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns type field + // Comment: Tornado, Severe Thunderstorm, etc. + /////////////////////////////////////////////////////////////////////// + FIT_WEATHER_SEVERE_TYPE GetType(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set type field + // Comment: Tornado, Severe Thunderstorm, etc. + /////////////////////////////////////////////////////////////////////// + void SetType(FIT_WEATHER_SEVERE_TYPE type) + { + SetFieldENUMValue(4, type, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WEATHER_ALERT_MESG_HPP) diff --git a/fit_weather_alert_mesg_listener.hpp b/fit_weather_alert_mesg_listener.hpp new file mode 100644 index 0000000..c4b0ddd --- /dev/null +++ b/fit_weather_alert_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WEATHER_ALERT_MESG_LISTENER_HPP) +#define FIT_WEATHER_ALERT_MESG_LISTENER_HPP + +#include "fit_weather_alert_mesg.hpp" + +namespace fit +{ + +class WeatherAlertMesgListener +{ +public: + virtual ~WeatherAlertMesgListener() {} + virtual void OnMesg(WeatherAlertMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WEATHER_ALERT_MESG_LISTENER_HPP) diff --git a/fit_weather_conditions_mesg.hpp b/fit_weather_conditions_mesg.hpp new file mode 100644 index 0000000..897c195 --- /dev/null +++ b/fit_weather_conditions_mesg.hpp @@ -0,0 +1,582 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WEATHER_CONDITIONS_MESG_HPP) +#define FIT_WEATHER_CONDITIONS_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WeatherConditionsMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 WeatherReport = 0; + static const FIT_UINT8 Temperature = 1; + static const FIT_UINT8 Condition = 2; + static const FIT_UINT8 WindDirection = 3; + static const FIT_UINT8 WindSpeed = 4; + static const FIT_UINT8 PrecipitationProbability = 5; + static const FIT_UINT8 TemperatureFeelsLike = 6; + static const FIT_UINT8 RelativeHumidity = 7; + static const FIT_UINT8 Location = 8; + static const FIT_UINT8 ObservedAtTime = 9; + static const FIT_UINT8 ObservedLocationLat = 10; + static const FIT_UINT8 ObservedLocationLong = 11; + static const FIT_UINT8 DayOfWeek = 12; + static const FIT_UINT8 HighTemperature = 13; + static const FIT_UINT8 LowTemperature = 14; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WeatherConditionsMesg(void) : Mesg(Profile::MESG_WEATHER_CONDITIONS) + { + } + + WeatherConditionsMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Comment: time of update for current conditions, else forecast time + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Comment: time of update for current conditions, else forecast time + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weather_report field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeatherReportValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weather_report field + // Comment: Current or forecast + /////////////////////////////////////////////////////////////////////// + FIT_WEATHER_REPORT GetWeatherReport(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weather_report field + // Comment: Current or forecast + /////////////////////////////////////////////////////////////////////// + void SetWeatherReport(FIT_WEATHER_REPORT weatherReport) + { + SetFieldENUMValue(0, weatherReport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetTemperature(void) const + { + return GetFieldSINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetTemperature(FIT_SINT8 temperature) + { + SetFieldSINT8Value(1, temperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of condition field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsConditionValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns condition field + // Comment: Corresponds to GSC Response weatherIcon field + /////////////////////////////////////////////////////////////////////// + FIT_WEATHER_STATUS GetCondition(void) const + { + return GetFieldENUMValue(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set condition field + // Comment: Corresponds to GSC Response weatherIcon field + /////////////////////////////////////////////////////////////////////// + void SetCondition(FIT_WEATHER_STATUS condition) + { + SetFieldENUMValue(2, condition, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wind_direction field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWindDirectionValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wind_direction field + // Units: degrees + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetWindDirection(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wind_direction field + // Units: degrees + /////////////////////////////////////////////////////////////////////// + void SetWindDirection(FIT_UINT16 windDirection) + { + SetFieldUINT16Value(3, windDirection, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wind_speed field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWindSpeedValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wind_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetWindSpeed(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wind_speed field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetWindSpeed(FIT_FLOAT32 windSpeed) + { + SetFieldFLOAT32Value(4, windSpeed, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of precipitation_probability field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPrecipitationProbabilityValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns precipitation_probability field + // Comment: range 0-100 + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetPrecipitationProbability(void) const + { + return GetFieldUINT8Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set precipitation_probability field + // Comment: range 0-100 + /////////////////////////////////////////////////////////////////////// + void SetPrecipitationProbability(FIT_UINT8 precipitationProbability) + { + SetFieldUINT8Value(5, precipitationProbability, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of temperature_feels_like field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTemperatureFeelsLikeValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns temperature_feels_like field + // Units: C + // Comment: Heat Index if GCS heatIdx above or equal to 90F or wind chill if GCS windChill below or equal to 32F + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetTemperatureFeelsLike(void) const + { + return GetFieldSINT8Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set temperature_feels_like field + // Units: C + // Comment: Heat Index if GCS heatIdx above or equal to 90F or wind chill if GCS windChill below or equal to 32F + /////////////////////////////////////////////////////////////////////// + void SetTemperatureFeelsLike(FIT_SINT8 temperatureFeelsLike) + { + SetFieldSINT8Value(6, temperatureFeelsLike, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of relative_humidity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRelativeHumidityValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns relative_humidity field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetRelativeHumidity(void) const + { + return GetFieldUINT8Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set relative_humidity field + /////////////////////////////////////////////////////////////////////// + void SetRelativeHumidity(FIT_UINT8 relativeHumidity) + { + SetFieldUINT8Value(7, relativeHumidity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of location field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLocationValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns location field + // Comment: string corresponding to GCS response location string + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetLocation(void) const + { + return GetFieldSTRINGValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set location field + // Comment: string corresponding to GCS response location string + /////////////////////////////////////////////////////////////////////// + void SetLocation(FIT_WSTRING location) + { + SetFieldSTRINGValue(8, location, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of observed_at_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsObservedAtTimeValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns observed_at_time field + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetObservedAtTime(void) const + { + return GetFieldUINT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set observed_at_time field + /////////////////////////////////////////////////////////////////////// + void SetObservedAtTime(FIT_DATE_TIME observedAtTime) + { + SetFieldUINT32Value(9, observedAtTime, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of observed_location_lat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsObservedLocationLatValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns observed_location_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetObservedLocationLat(void) const + { + return GetFieldSINT32Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set observed_location_lat field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetObservedLocationLat(FIT_SINT32 observedLocationLat) + { + SetFieldSINT32Value(10, observedLocationLat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of observed_location_long field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsObservedLocationLongValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns observed_location_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + FIT_SINT32 GetObservedLocationLong(void) const + { + return GetFieldSINT32Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set observed_location_long field + // Units: semicircles + /////////////////////////////////////////////////////////////////////// + void SetObservedLocationLong(FIT_SINT32 observedLocationLong) + { + SetFieldSINT32Value(11, observedLocationLong, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of day_of_week field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDayOfWeekValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns day_of_week field + /////////////////////////////////////////////////////////////////////// + FIT_DAY_OF_WEEK GetDayOfWeek(void) const + { + return GetFieldENUMValue(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set day_of_week field + /////////////////////////////////////////////////////////////////////// + void SetDayOfWeek(FIT_DAY_OF_WEEK dayOfWeek) + { + SetFieldENUMValue(12, dayOfWeek, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of high_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHighTemperatureValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns high_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetHighTemperature(void) const + { + return GetFieldSINT8Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set high_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetHighTemperature(FIT_SINT8 highTemperature) + { + SetFieldSINT8Value(13, highTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of low_temperature field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsLowTemperatureValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns low_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + FIT_SINT8 GetLowTemperature(void) const + { + return GetFieldSINT8Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set low_temperature field + // Units: C + /////////////////////////////////////////////////////////////////////// + void SetLowTemperature(FIT_SINT8 lowTemperature) + { + SetFieldSINT8Value(14, lowTemperature, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WEATHER_CONDITIONS_MESG_HPP) diff --git a/fit_weather_conditions_mesg_listener.hpp b/fit_weather_conditions_mesg_listener.hpp new file mode 100644 index 0000000..e69f6ce --- /dev/null +++ b/fit_weather_conditions_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WEATHER_CONDITIONS_MESG_LISTENER_HPP) +#define FIT_WEATHER_CONDITIONS_MESG_LISTENER_HPP + +#include "fit_weather_conditions_mesg.hpp" + +namespace fit +{ + +class WeatherConditionsMesgListener +{ +public: + virtual ~WeatherConditionsMesgListener() {} + virtual void OnMesg(WeatherConditionsMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WEATHER_CONDITIONS_MESG_LISTENER_HPP) diff --git a/fit_weight_scale_mesg.hpp b/fit_weight_scale_mesg.hpp new file mode 100644 index 0000000..664cf3f --- /dev/null +++ b/fit_weight_scale_mesg.hpp @@ -0,0 +1,516 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WEIGHT_SCALE_MESG_HPP) +#define FIT_WEIGHT_SCALE_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WeightScaleMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 Timestamp = 253; + static const FIT_UINT8 Weight = 0; + static const FIT_UINT8 PercentFat = 1; + static const FIT_UINT8 PercentHydration = 2; + static const FIT_UINT8 VisceralFatMass = 3; + static const FIT_UINT8 BoneMass = 4; + static const FIT_UINT8 MuscleMass = 5; + static const FIT_UINT8 BasalMet = 7; + static const FIT_UINT8 PhysiqueRating = 8; + static const FIT_UINT8 ActiveMet = 9; + static const FIT_UINT8 MetabolicAge = 10; + static const FIT_UINT8 VisceralFatRating = 11; + static const FIT_UINT8 UserProfileIndex = 12; + static const FIT_UINT8 Bmi = 13; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WeightScaleMesg(void) : Mesg(Profile::MESG_WEIGHT_SCALE) + { + } + + WeightScaleMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of timestamp field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTimestampValid() const + { + const Field* field = GetField(253); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_DATE_TIME GetTimestamp(void) const + { + return GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set timestamp field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetTimestamp(FIT_DATE_TIME timestamp) + { + SetFieldUINT32Value(253, timestamp, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weight field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeightValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetWeight(void) const + { + return GetFieldFLOAT32Value(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetWeight(FIT_FLOAT32 weight) + { + SetFieldFLOAT32Value(0, weight, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of percent_fat field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPercentFatValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns percent_fat field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPercentFat(void) const + { + return GetFieldFLOAT32Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set percent_fat field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetPercentFat(FIT_FLOAT32 percentFat) + { + SetFieldFLOAT32Value(1, percentFat, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of percent_hydration field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPercentHydrationValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns percent_hydration field + // Units: % + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPercentHydration(void) const + { + return GetFieldFLOAT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set percent_hydration field + // Units: % + /////////////////////////////////////////////////////////////////////// + void SetPercentHydration(FIT_FLOAT32 percentHydration) + { + SetFieldFLOAT32Value(2, percentHydration, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of visceral_fat_mass field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVisceralFatMassValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns visceral_fat_mass field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetVisceralFatMass(void) const + { + return GetFieldFLOAT32Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set visceral_fat_mass field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetVisceralFatMass(FIT_FLOAT32 visceralFatMass) + { + SetFieldFLOAT32Value(3, visceralFatMass, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bone_mass field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBoneMassValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bone_mass field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBoneMass(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bone_mass field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetBoneMass(FIT_FLOAT32 boneMass) + { + SetFieldFLOAT32Value(4, boneMass, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of muscle_mass field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMuscleMassValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns muscle_mass field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetMuscleMass(void) const + { + return GetFieldFLOAT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set muscle_mass field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetMuscleMass(FIT_FLOAT32 muscleMass) + { + SetFieldFLOAT32Value(5, muscleMass, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of basal_met field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBasalMetValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns basal_met field + // Units: kcal/day + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBasalMet(void) const + { + return GetFieldFLOAT32Value(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set basal_met field + // Units: kcal/day + /////////////////////////////////////////////////////////////////////// + void SetBasalMet(FIT_FLOAT32 basalMet) + { + SetFieldFLOAT32Value(7, basalMet, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of physique_rating field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPhysiqueRatingValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns physique_rating field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetPhysiqueRating(void) const + { + return GetFieldUINT8Value(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set physique_rating field + /////////////////////////////////////////////////////////////////////// + void SetPhysiqueRating(FIT_UINT8 physiqueRating) + { + SetFieldUINT8Value(8, physiqueRating, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of active_met field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsActiveMetValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns active_met field + // Units: kcal/day + // Comment: ~4kJ per kcal, 0.25 allows max 16384 kcal + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetActiveMet(void) const + { + return GetFieldFLOAT32Value(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set active_met field + // Units: kcal/day + // Comment: ~4kJ per kcal, 0.25 allows max 16384 kcal + /////////////////////////////////////////////////////////////////////// + void SetActiveMet(FIT_FLOAT32 activeMet) + { + SetFieldFLOAT32Value(9, activeMet, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of metabolic_age field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMetabolicAgeValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns metabolic_age field + // Units: years + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMetabolicAge(void) const + { + return GetFieldUINT8Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set metabolic_age field + // Units: years + /////////////////////////////////////////////////////////////////////// + void SetMetabolicAge(FIT_UINT8 metabolicAge) + { + SetFieldUINT8Value(10, metabolicAge, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of visceral_fat_rating field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsVisceralFatRatingValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns visceral_fat_rating field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetVisceralFatRating(void) const + { + return GetFieldUINT8Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set visceral_fat_rating field + /////////////////////////////////////////////////////////////////////// + void SetVisceralFatRating(FIT_UINT8 visceralFatRating) + { + SetFieldUINT8Value(11, visceralFatRating, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of user_profile_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsUserProfileIndexValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns user_profile_index field + // Comment: Associates this weight scale message to a user. This corresponds to the index of the user profile message in the weight scale file. + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetUserProfileIndex(void) const + { + return GetFieldUINT16Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set user_profile_index field + // Comment: Associates this weight scale message to a user. This corresponds to the index of the user profile message in the weight scale file. + /////////////////////////////////////////////////////////////////////// + void SetUserProfileIndex(FIT_MESSAGE_INDEX userProfileIndex) + { + SetFieldUINT16Value(12, userProfileIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of bmi field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsBmiValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns bmi field + // Units: kg/m^2 + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetBmi(void) const + { + return GetFieldFLOAT32Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set bmi field + // Units: kg/m^2 + /////////////////////////////////////////////////////////////////////// + void SetBmi(FIT_FLOAT32 bmi) + { + SetFieldFLOAT32Value(13, bmi, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WEIGHT_SCALE_MESG_HPP) diff --git a/fit_weight_scale_mesg_listener.hpp b/fit_weight_scale_mesg_listener.hpp new file mode 100644 index 0000000..b9b4aa0 --- /dev/null +++ b/fit_weight_scale_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WEIGHT_SCALE_MESG_LISTENER_HPP) +#define FIT_WEIGHT_SCALE_MESG_LISTENER_HPP + +#include "fit_weight_scale_mesg.hpp" + +namespace fit +{ + +class WeightScaleMesgListener +{ +public: + virtual ~WeightScaleMesgListener() {} + virtual void OnMesg(WeightScaleMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WEIGHT_SCALE_MESG_LISTENER_HPP) diff --git a/fit_workout_mesg.hpp b/fit_workout_mesg.hpp new file mode 100644 index 0000000..a5b72dd --- /dev/null +++ b/fit_workout_mesg.hpp @@ -0,0 +1,336 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WORKOUT_MESG_HPP) +#define FIT_WORKOUT_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WorkoutMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Sport = 4; + static const FIT_UINT8 Capabilities = 5; + static const FIT_UINT8 NumValidSteps = 6; + static const FIT_UINT8 WktName = 8; + static const FIT_UINT8 SubSport = 11; + static const FIT_UINT8 PoolLength = 14; + static const FIT_UINT8 PoolLengthUnit = 15; + static const FIT_UINT8 WktDescription = 17; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WorkoutMesg(void) : Mesg(Profile::MESG_WORKOUT) + { + } + + WorkoutMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(4, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of capabilities field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCapabilitiesValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns capabilities field + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_CAPABILITIES GetCapabilities(void) const + { + return GetFieldUINT32ZValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set capabilities field + /////////////////////////////////////////////////////////////////////// + void SetCapabilities(FIT_WORKOUT_CAPABILITIES capabilities) + { + SetFieldUINT32ZValue(5, capabilities, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_valid_steps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumValidStepsValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_valid_steps field + // Comment: number of valid steps + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumValidSteps(void) const + { + return GetFieldUINT16Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_valid_steps field + // Comment: number of valid steps + /////////////////////////////////////////////////////////////////////// + void SetNumValidSteps(FIT_UINT16 numValidSteps) + { + SetFieldUINT16Value(6, numValidSteps, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktNameValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetWktName(void) const + { + return GetFieldSTRINGValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_name field + /////////////////////////////////////////////////////////////////////// + void SetWktName(FIT_WSTRING wktName) + { + SetFieldSTRINGValue(8, wktName, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(11, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pool_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPoolLengthValid() const + { + const Field* field = GetField(14); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pool_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPoolLength(void) const + { + return GetFieldFLOAT32Value(14, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pool_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetPoolLength(FIT_FLOAT32 poolLength) + { + SetFieldFLOAT32Value(14, poolLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pool_length_unit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPoolLengthUnitValid() const + { + const Field* field = GetField(15); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pool_length_unit field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetPoolLengthUnit(void) const + { + return GetFieldENUMValue(15, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pool_length_unit field + /////////////////////////////////////////////////////////////////////// + void SetPoolLengthUnit(FIT_DISPLAY_MEASURE poolLengthUnit) + { + SetFieldENUMValue(15, poolLengthUnit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_description field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktDescriptionValid() const + { + const Field* field = GetField(17); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_description field + // Comment: Description of the workout + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetWktDescription(void) const + { + return GetFieldSTRINGValue(17, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_description field + // Comment: Description of the workout + /////////////////////////////////////////////////////////////////////// + void SetWktDescription(FIT_WSTRING wktDescription) + { + SetFieldSTRINGValue(17, wktDescription, 0); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WORKOUT_MESG_HPP) diff --git a/fit_workout_mesg_listener.hpp b/fit_workout_mesg_listener.hpp new file mode 100644 index 0000000..f617ffb --- /dev/null +++ b/fit_workout_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WORKOUT_MESG_LISTENER_HPP) +#define FIT_WORKOUT_MESG_LISTENER_HPP + +#include "fit_workout_mesg.hpp" + +namespace fit +{ + +class WorkoutMesgListener +{ +public: + virtual ~WorkoutMesgListener() {} + virtual void OnMesg(WorkoutMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WORKOUT_MESG_LISTENER_HPP) diff --git a/fit_workout_session_mesg.hpp b/fit_workout_session_mesg.hpp new file mode 100644 index 0000000..efcc740 --- /dev/null +++ b/fit_workout_session_mesg.hpp @@ -0,0 +1,268 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WORKOUT_SESSION_MESG_HPP) +#define FIT_WORKOUT_SESSION_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WorkoutSessionMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 Sport = 0; + static const FIT_UINT8 SubSport = 1; + static const FIT_UINT8 NumValidSteps = 2; + static const FIT_UINT8 FirstStepIndex = 3; + static const FIT_UINT8 PoolLength = 4; + static const FIT_UINT8 PoolLengthUnit = 5; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WorkoutSessionMesg(void) : Mesg(Profile::MESG_WORKOUT_SESSION) + { + } + + WorkoutSessionMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSportValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sport field + /////////////////////////////////////////////////////////////////////// + FIT_SPORT GetSport(void) const + { + return GetFieldENUMValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sport field + /////////////////////////////////////////////////////////////////////// + void SetSport(FIT_SPORT sport) + { + SetFieldENUMValue(0, sport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of sub_sport field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSubSportValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns sub_sport field + /////////////////////////////////////////////////////////////////////// + FIT_SUB_SPORT GetSubSport(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set sub_sport field + /////////////////////////////////////////////////////////////////////// + void SetSubSport(FIT_SUB_SPORT subSport) + { + SetFieldENUMValue(1, subSport, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of num_valid_steps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNumValidStepsValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns num_valid_steps field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetNumValidSteps(void) const + { + return GetFieldUINT16Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set num_valid_steps field + /////////////////////////////////////////////////////////////////////// + void SetNumValidSteps(FIT_UINT16 numValidSteps) + { + SetFieldUINT16Value(2, numValidSteps, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of first_step_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFirstStepIndexValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns first_step_index field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetFirstStepIndex(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set first_step_index field + /////////////////////////////////////////////////////////////////////// + void SetFirstStepIndex(FIT_UINT16 firstStepIndex) + { + SetFieldUINT16Value(3, firstStepIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pool_length field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPoolLengthValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pool_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetPoolLength(void) const + { + return GetFieldFLOAT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pool_length field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetPoolLength(FIT_FLOAT32 poolLength) + { + SetFieldFLOAT32Value(4, poolLength, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pool_length_unit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPoolLengthUnitValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pool_length_unit field + /////////////////////////////////////////////////////////////////////// + FIT_DISPLAY_MEASURE GetPoolLengthUnit(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pool_length_unit field + /////////////////////////////////////////////////////////////////////// + void SetPoolLengthUnit(FIT_DISPLAY_MEASURE poolLengthUnit) + { + SetFieldENUMValue(5, poolLengthUnit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WORKOUT_SESSION_MESG_HPP) diff --git a/fit_workout_session_mesg_listener.hpp b/fit_workout_session_mesg_listener.hpp new file mode 100644 index 0000000..eed6c69 --- /dev/null +++ b/fit_workout_session_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WORKOUT_SESSION_MESG_LISTENER_HPP) +#define FIT_WORKOUT_SESSION_MESG_LISTENER_HPP + +#include "fit_workout_session_mesg.hpp" + +namespace fit +{ + +class WorkoutSessionMesgListener +{ +public: + virtual ~WorkoutSessionMesgListener() {} + virtual void OnMesg(WorkoutSessionMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WORKOUT_SESSION_MESG_LISTENER_HPP) diff --git a/fit_workout_step_mesg.hpp b/fit_workout_step_mesg.hpp new file mode 100644 index 0000000..121dbaa --- /dev/null +++ b/fit_workout_step_mesg.hpp @@ -0,0 +1,2167 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WORKOUT_STEP_MESG_HPP) +#define FIT_WORKOUT_STEP_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class WorkoutStepMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MessageIndex = 254; + static const FIT_UINT8 WktStepName = 0; + static const FIT_UINT8 DurationType = 1; + static const FIT_UINT8 DurationValue = 2; + static const FIT_UINT8 TargetType = 3; + static const FIT_UINT8 TargetValue = 4; + static const FIT_UINT8 CustomTargetValueLow = 5; + static const FIT_UINT8 CustomTargetValueHigh = 6; + static const FIT_UINT8 Intensity = 7; + static const FIT_UINT8 Notes = 8; + static const FIT_UINT8 Equipment = 9; + static const FIT_UINT8 ExerciseCategory = 10; + static const FIT_UINT8 ExerciseName = 11; + static const FIT_UINT8 ExerciseWeight = 12; + static const FIT_UINT8 WeightDisplayUnit = 13; + static const FIT_UINT8 SecondaryTargetType = 19; + static const FIT_UINT8 SecondaryTargetValue = 20; + static const FIT_UINT8 SecondaryCustomTargetValueLow = 21; + static const FIT_UINT8 SecondaryCustomTargetValueHigh = 22; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + WorkoutStepMesg(void) : Mesg(Profile::MESG_WORKOUT_STEP) + { + } + + WorkoutStepMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of message_index field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMessageIndexValid() const + { + const Field* field = GetField(254); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns message_index field + /////////////////////////////////////////////////////////////////////// + FIT_MESSAGE_INDEX GetMessageIndex(void) const + { + return GetFieldUINT16Value(254, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set message_index field + /////////////////////////////////////////////////////////////////////// + void SetMessageIndex(FIT_MESSAGE_INDEX messageIndex) + { + SetFieldUINT16Value(254, messageIndex, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of wkt_step_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWktStepNameValid() const + { + const Field* field = GetField(0); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns wkt_step_name field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetWktStepName(void) const + { + return GetFieldSTRINGValue(0, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set wkt_step_name field + /////////////////////////////////////////////////////////////////////// + void SetWktStepName(FIT_WSTRING wktStepName) + { + SetFieldSTRINGValue(0, wktStepName, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationTypeValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns duration_type field + /////////////////////////////////////////////////////////////////////// + FIT_WKT_STEP_DURATION GetDurationType(void) const + { + return GetFieldENUMValue(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_type field + /////////////////////////////////////////////////////////////////////// + void SetDurationType(FIT_WKT_STEP_DURATION durationType) + { + SetFieldENUMValue(1, durationType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationValueValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns duration_value field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDurationValue(void) const + { + return GetFieldUINT32Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_value field + /////////////////////////////////////////////////////////////////////// + void SetDurationValue(FIT_UINT32 durationValue) + { + SetFieldUINT32Value(2, durationValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationTimeValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_TIME ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_TIME); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDurationTime(void) const + { + return GetFieldFLOAT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_TIME); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetDurationTime(FIT_FLOAT32 durationTime) + { + SetFieldFLOAT32Value(2, durationTime, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_TIME); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationDistanceValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_DISTANCE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_DISTANCE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetDurationDistance(void) const + { + return GetFieldFLOAT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_DISTANCE); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetDurationDistance(FIT_FLOAT32 durationDistance) + { + SetFieldFLOAT32Value(2, durationDistance, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_DISTANCE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_hr field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationHrValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_HR ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_HR); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_hr field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_HR GetDurationHr(void) const + { + return GetFieldUINT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_HR); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_hr field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + void SetDurationHr(FIT_WORKOUT_HR durationHr) + { + SetFieldUINT32Value(2, durationHr, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_HR); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationCaloriesValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_CALORIES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_CALORIES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_calories field + // Units: calories + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDurationCalories(void) const + { + return GetFieldUINT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_CALORIES); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_calories field + // Units: calories + /////////////////////////////////////////////////////////////////////// + void SetDurationCalories(FIT_UINT32 durationCalories) + { + SetFieldUINT32Value(2, durationCalories, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_CALORIES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_step field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationStepValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_STEP ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_STEP); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_step field + // Comment: message_index of step to loop back to. Steps are assumed to be in the order by message_index. custom_name and intensity members are undefined for this duration type. + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDurationStep(void) const + { + return GetFieldUINT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_STEP); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_step field + // Comment: message_index of step to loop back to. Steps are assumed to be in the order by message_index. custom_name and intensity members are undefined for this duration type. + /////////////////////////////////////////////////////////////////////// + void SetDurationStep(FIT_UINT32 durationStep) + { + SetFieldUINT32Value(2, durationStep, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_STEP); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationPowerValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_POWER ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_POWER); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_power field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_POWER GetDurationPower(void) const + { + return GetFieldUINT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_POWER); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_power field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + void SetDurationPower(FIT_WORKOUT_POWER durationPower) + { + SetFieldUINT32Value(2, durationPower, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_POWER); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of duration_reps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsDurationRepsValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_REPS ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_REPS); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns duration_reps field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetDurationReps(void) const + { + return GetFieldUINT32Value(2, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_REPS); + } + + /////////////////////////////////////////////////////////////////////// + // Set duration_reps field + /////////////////////////////////////////////////////////////////////// + void SetDurationReps(FIT_UINT32 durationReps) + { + SetFieldUINT32Value(2, durationReps, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_DURATION_VALUE_FIELD_DURATION_REPS); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetTypeValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns target_type field + /////////////////////////////////////////////////////////////////////// + FIT_WKT_STEP_TARGET GetTargetType(void) const + { + return GetFieldENUMValue(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_type field + /////////////////////////////////////////////////////////////////////// + void SetTargetType(FIT_WKT_STEP_TARGET targetType) + { + SetFieldENUMValue(3, targetType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetValueValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns target_value field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetValue(void) const + { + return GetFieldUINT32Value(4, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_value field + /////////////////////////////////////////////////////////////////////// + void SetTargetValue(FIT_UINT32 targetValue) + { + SetFieldUINT32Value(4, targetValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_speed_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetSpeedZoneValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_SPEED_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_SPEED_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns target_speed_zone field + // Comment: speed zone (1-10);Custom =0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetSpeedZone(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_SPEED_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_speed_zone field + // Comment: speed zone (1-10);Custom =0; + /////////////////////////////////////////////////////////////////////// + void SetTargetSpeedZone(FIT_UINT32 targetSpeedZone) + { + SetFieldUINT32Value(4, targetSpeedZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_SPEED_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_hr_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetHrZoneValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_HR_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_HR_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns target_hr_zone field + // Comment: hr zone (1-5);Custom =0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetHrZone(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_HR_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_hr_zone field + // Comment: hr zone (1-5);Custom =0; + /////////////////////////////////////////////////////////////////////// + void SetTargetHrZone(FIT_UINT32 targetHrZone) + { + SetFieldUINT32Value(4, targetHrZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_HR_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_cadence_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetCadenceZoneValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_CADENCE_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_CADENCE_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns target_cadence_zone field + // Comment: Zone (1-?); Custom = 0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetCadenceZone(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_CADENCE_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_cadence_zone field + // Comment: Zone (1-?); Custom = 0; + /////////////////////////////////////////////////////////////////////// + void SetTargetCadenceZone(FIT_UINT32 targetCadenceZone) + { + SetFieldUINT32Value(4, targetCadenceZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_CADENCE_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_power_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetPowerZoneValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_POWER_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_POWER_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns target_power_zone field + // Comment: Power Zone ( 1-7); Custom = 0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetTargetPowerZone(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_POWER_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_power_zone field + // Comment: Power Zone ( 1-7); Custom = 0; + /////////////////////////////////////////////////////////////////////// + void SetTargetPowerZone(FIT_UINT32 targetPowerZone) + { + SetFieldUINT32Value(4, targetPowerZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_POWER_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_steps field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatStepsValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_STEPS ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_STEPS); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_steps field + // Comment: # of repetitions + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetRepeatSteps(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_STEPS); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_steps field + // Comment: # of repetitions + /////////////////////////////////////////////////////////////////////// + void SetRepeatSteps(FIT_UINT32 repeatSteps) + { + SetFieldUINT32Value(4, repeatSteps, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_STEPS); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_time field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatTimeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_TIME ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_TIME); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRepeatTime(void) const + { + return GetFieldFLOAT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_TIME); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_time field + // Units: s + /////////////////////////////////////////////////////////////////////// + void SetRepeatTime(FIT_FLOAT32 repeatTime) + { + SetFieldFLOAT32Value(4, repeatTime, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_TIME); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_distance field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatDistanceValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_DISTANCE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_DISTANCE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetRepeatDistance(void) const + { + return GetFieldFLOAT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_DISTANCE); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_distance field + // Units: m + /////////////////////////////////////////////////////////////////////// + void SetRepeatDistance(FIT_FLOAT32 repeatDistance) + { + SetFieldFLOAT32Value(4, repeatDistance, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_DISTANCE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_calories field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatCaloriesValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_CALORIES ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_CALORIES); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_calories field + // Units: calories + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetRepeatCalories(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_CALORIES); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_calories field + // Units: calories + /////////////////////////////////////////////////////////////////////// + void SetRepeatCalories(FIT_UINT32 repeatCalories) + { + SetFieldUINT32Value(4, repeatCalories, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_CALORIES); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_hr field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatHrValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_HR ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_HR); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_hr field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_HR GetRepeatHr(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_HR); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_hr field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + void SetRepeatHr(FIT_WORKOUT_HR repeatHr) + { + SetFieldUINT32Value(4, repeatHr, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_HR); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of repeat_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsRepeatPowerValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_POWER ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_POWER); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns repeat_power field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_POWER GetRepeatPower(void) const + { + return GetFieldUINT32Value(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_POWER); + } + + /////////////////////////////////////////////////////////////////////// + // Set repeat_power field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + void SetRepeatPower(FIT_WORKOUT_POWER repeatPower) + { + SetFieldUINT32Value(4, repeatPower, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_REPEAT_POWER); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of target_stroke_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsTargetStrokeTypeValid() const + { + const Field* field = GetField(4); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_STROKE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_STROKE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns target_stroke_type field + /////////////////////////////////////////////////////////////////////// + FIT_SWIM_STROKE GetTargetStrokeType(void) const + { + return GetFieldENUMValue(4, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_STROKE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set target_stroke_type field + /////////////////////////////////////////////////////////////////////// + void SetTargetStrokeType(FIT_SWIM_STROKE targetStrokeType) + { + SetFieldENUMValue(4, targetStrokeType, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_TARGET_VALUE_FIELD_TARGET_STROKE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_value_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetValueLowValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_value_low field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCustomTargetValueLow(void) const + { + return GetFieldUINT32Value(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_value_low field + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetValueLow(FIT_UINT32 customTargetValueLow) + { + SetFieldUINT32Value(5, customTargetValueLow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_speed_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetSpeedLowValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_SPEED_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_SPEED_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_speed_low field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCustomTargetSpeedLow(void) const + { + return GetFieldFLOAT32Value(5, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_SPEED_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_speed_low field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetSpeedLow(FIT_FLOAT32 customTargetSpeedLow) + { + SetFieldFLOAT32Value(5, customTargetSpeedLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_SPEED_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_heart_rate_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetHeartRateLowValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_HEART_RATE_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_HEART_RATE_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_heart_rate_low field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_HR GetCustomTargetHeartRateLow(void) const + { + return GetFieldUINT32Value(5, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_HEART_RATE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_heart_rate_low field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetHeartRateLow(FIT_WORKOUT_HR customTargetHeartRateLow) + { + SetFieldUINT32Value(5, customTargetHeartRateLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_HEART_RATE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_cadence_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetCadenceLowValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_CADENCE_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_CADENCE_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_cadence_low field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCustomTargetCadenceLow(void) const + { + return GetFieldUINT32Value(5, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_CADENCE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_cadence_low field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetCadenceLow(FIT_UINT32 customTargetCadenceLow) + { + SetFieldUINT32Value(5, customTargetCadenceLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_CADENCE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_power_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetPowerLowValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_POWER_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_POWER_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_power_low field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_POWER GetCustomTargetPowerLow(void) const + { + return GetFieldUINT32Value(5, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_POWER_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_power_low field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetPowerLow(FIT_WORKOUT_POWER customTargetPowerLow) + { + SetFieldUINT32Value(5, customTargetPowerLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_LOW_FIELD_CUSTOM_TARGET_POWER_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_value_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetValueHighValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_value_high field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCustomTargetValueHigh(void) const + { + return GetFieldUINT32Value(6, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_value_high field + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetValueHigh(FIT_UINT32 customTargetValueHigh) + { + SetFieldUINT32Value(6, customTargetValueHigh, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_speed_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetSpeedHighValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_SPEED_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_SPEED_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_speed_high field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetCustomTargetSpeedHigh(void) const + { + return GetFieldFLOAT32Value(6, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_SPEED_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_speed_high field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetSpeedHigh(FIT_FLOAT32 customTargetSpeedHigh) + { + SetFieldFLOAT32Value(6, customTargetSpeedHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_SPEED_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_heart_rate_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetHeartRateHighValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_HEART_RATE_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_HEART_RATE_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_heart_rate_high field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_HR GetCustomTargetHeartRateHigh(void) const + { + return GetFieldUINT32Value(6, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_HEART_RATE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_heart_rate_high field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetHeartRateHigh(FIT_WORKOUT_HR customTargetHeartRateHigh) + { + SetFieldUINT32Value(6, customTargetHeartRateHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_HEART_RATE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_cadence_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetCadenceHighValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_CADENCE_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_CADENCE_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_cadence_high field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetCustomTargetCadenceHigh(void) const + { + return GetFieldUINT32Value(6, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_CADENCE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_cadence_high field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetCadenceHigh(FIT_UINT32 customTargetCadenceHigh) + { + SetFieldUINT32Value(6, customTargetCadenceHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_CADENCE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of custom_target_power_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsCustomTargetPowerHighValid() const + { + const Field* field = GetField(6); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_POWER_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_POWER_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns custom_target_power_high field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_POWER GetCustomTargetPowerHigh(void) const + { + return GetFieldUINT32Value(6, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_POWER_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set custom_target_power_high field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + void SetCustomTargetPowerHigh(FIT_WORKOUT_POWER customTargetPowerHigh) + { + SetFieldUINT32Value(6, customTargetPowerHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_CUSTOM_TARGET_VALUE_HIGH_FIELD_CUSTOM_TARGET_POWER_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of intensity field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsIntensityValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns intensity field + /////////////////////////////////////////////////////////////////////// + FIT_INTENSITY GetIntensity(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set intensity field + /////////////////////////////////////////////////////////////////////// + void SetIntensity(FIT_INTENSITY intensity) + { + SetFieldENUMValue(7, intensity, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of notes field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsNotesValid() const + { + const Field* field = GetField(8); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns notes field + /////////////////////////////////////////////////////////////////////// + FIT_WSTRING GetNotes(void) const + { + return GetFieldSTRINGValue(8, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set notes field + /////////////////////////////////////////////////////////////////////// + void SetNotes(FIT_WSTRING notes) + { + SetFieldSTRINGValue(8, notes, 0); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of equipment field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsEquipmentValid() const + { + const Field* field = GetField(9); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns equipment field + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_EQUIPMENT GetEquipment(void) const + { + return GetFieldENUMValue(9, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set equipment field + /////////////////////////////////////////////////////////////////////// + void SetEquipment(FIT_WORKOUT_EQUIPMENT equipment) + { + SetFieldENUMValue(9, equipment, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of exercise_category field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsExerciseCategoryValid() const + { + const Field* field = GetField(10); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns exercise_category field + /////////////////////////////////////////////////////////////////////// + FIT_EXERCISE_CATEGORY GetExerciseCategory(void) const + { + return GetFieldUINT16Value(10, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set exercise_category field + /////////////////////////////////////////////////////////////////////// + void SetExerciseCategory(FIT_EXERCISE_CATEGORY exerciseCategory) + { + SetFieldUINT16Value(10, exerciseCategory, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of exercise_name field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsExerciseNameValid() const + { + const Field* field = GetField(11); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns exercise_name field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetExerciseName(void) const + { + return GetFieldUINT16Value(11, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set exercise_name field + /////////////////////////////////////////////////////////////////////// + void SetExerciseName(FIT_UINT16 exerciseName) + { + SetFieldUINT16Value(11, exerciseName, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of exercise_weight field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsExerciseWeightValid() const + { + const Field* field = GetField(12); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns exercise_weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetExerciseWeight(void) const + { + return GetFieldFLOAT32Value(12, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set exercise_weight field + // Units: kg + /////////////////////////////////////////////////////////////////////// + void SetExerciseWeight(FIT_FLOAT32 exerciseWeight) + { + SetFieldFLOAT32Value(12, exerciseWeight, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of weight_display_unit field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsWeightDisplayUnitValid() const + { + const Field* field = GetField(13); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns weight_display_unit field + /////////////////////////////////////////////////////////////////////// + FIT_FIT_BASE_UNIT GetWeightDisplayUnit(void) const + { + return GetFieldUINT16Value(13, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set weight_display_unit field + /////////////////////////////////////////////////////////////////////// + void SetWeightDisplayUnit(FIT_FIT_BASE_UNIT weightDisplayUnit) + { + SetFieldUINT16Value(13, weightDisplayUnit, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetTypeValid() const + { + const Field* field = GetField(19); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_type field + /////////////////////////////////////////////////////////////////////// + FIT_WKT_STEP_TARGET GetSecondaryTargetType(void) const + { + return GetFieldENUMValue(19, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_type field + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetType(FIT_WKT_STEP_TARGET secondaryTargetType) + { + SetFieldENUMValue(19, secondaryTargetType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_value field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetValueValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_value field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryTargetValue(void) const + { + return GetFieldUINT32Value(20, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_value field + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetValue(FIT_UINT32 secondaryTargetValue) + { + SetFieldUINT32Value(20, secondaryTargetValue, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_speed_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetSpeedZoneValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_SPEED_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_SPEED_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_speed_zone field + // Comment: speed zone (1-10);Custom =0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryTargetSpeedZone(void) const + { + return GetFieldUINT32Value(20, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_SPEED_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_speed_zone field + // Comment: speed zone (1-10);Custom =0; + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetSpeedZone(FIT_UINT32 secondaryTargetSpeedZone) + { + SetFieldUINT32Value(20, secondaryTargetSpeedZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_SPEED_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_hr_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetHrZoneValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_HR_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_HR_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_hr_zone field + // Comment: hr zone (1-5);Custom =0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryTargetHrZone(void) const + { + return GetFieldUINT32Value(20, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_HR_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_hr_zone field + // Comment: hr zone (1-5);Custom =0; + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetHrZone(FIT_UINT32 secondaryTargetHrZone) + { + SetFieldUINT32Value(20, secondaryTargetHrZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_HR_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_cadence_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetCadenceZoneValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_CADENCE_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_CADENCE_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_cadence_zone field + // Comment: Zone (1-?); Custom = 0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryTargetCadenceZone(void) const + { + return GetFieldUINT32Value(20, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_CADENCE_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_cadence_zone field + // Comment: Zone (1-?); Custom = 0; + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetCadenceZone(FIT_UINT32 secondaryTargetCadenceZone) + { + SetFieldUINT32Value(20, secondaryTargetCadenceZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_CADENCE_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_power_zone field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetPowerZoneValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_POWER_ZONE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_POWER_ZONE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_power_zone field + // Comment: Power Zone ( 1-7); Custom = 0; + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryTargetPowerZone(void) const + { + return GetFieldUINT32Value(20, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_POWER_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_power_zone field + // Comment: Power Zone ( 1-7); Custom = 0; + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetPowerZone(FIT_UINT32 secondaryTargetPowerZone) + { + SetFieldUINT32Value(20, secondaryTargetPowerZone, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_POWER_ZONE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_target_stroke_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryTargetStrokeTypeValid() const + { + const Field* field = GetField(20); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_STROKE_TYPE ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_STROKE_TYPE); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_target_stroke_type field + /////////////////////////////////////////////////////////////////////// + FIT_SWIM_STROKE GetSecondaryTargetStrokeType(void) const + { + return GetFieldENUMValue(20, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_STROKE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_target_stroke_type field + /////////////////////////////////////////////////////////////////////// + void SetSecondaryTargetStrokeType(FIT_SWIM_STROKE secondaryTargetStrokeType) + { + SetFieldENUMValue(20, secondaryTargetStrokeType, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_TARGET_VALUE_FIELD_SECONDARY_TARGET_STROKE_TYPE); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_value_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetValueLowValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_value_low field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryCustomTargetValueLow(void) const + { + return GetFieldUINT32Value(21, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_value_low field + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetValueLow(FIT_UINT32 secondaryCustomTargetValueLow) + { + SetFieldUINT32Value(21, secondaryCustomTargetValueLow, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_speed_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetSpeedLowValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_speed_low field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSecondaryCustomTargetSpeedLow(void) const + { + return GetFieldFLOAT32Value(21, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_speed_low field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetSpeedLow(FIT_FLOAT32 secondaryCustomTargetSpeedLow) + { + SetFieldFLOAT32Value(21, secondaryCustomTargetSpeedLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_heart_rate_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetHeartRateLowValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_heart_rate_low field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_HR GetSecondaryCustomTargetHeartRateLow(void) const + { + return GetFieldUINT32Value(21, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_heart_rate_low field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetHeartRateLow(FIT_WORKOUT_HR secondaryCustomTargetHeartRateLow) + { + SetFieldUINT32Value(21, secondaryCustomTargetHeartRateLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_cadence_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetCadenceLowValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_cadence_low field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryCustomTargetCadenceLow(void) const + { + return GetFieldUINT32Value(21, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_cadence_low field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetCadenceLow(FIT_UINT32 secondaryCustomTargetCadenceLow) + { + SetFieldUINT32Value(21, secondaryCustomTargetCadenceLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_power_low field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetPowerLowValid() const + { + const Field* field = GetField(21); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_POWER_LOW ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_POWER_LOW); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_power_low field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_POWER GetSecondaryCustomTargetPowerLow(void) const + { + return GetFieldUINT32Value(21, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_POWER_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_power_low field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetPowerLow(FIT_WORKOUT_POWER secondaryCustomTargetPowerLow) + { + SetFieldUINT32Value(21, secondaryCustomTargetPowerLow, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_LOW_FIELD_SECONDARY_CUSTOM_TARGET_POWER_LOW); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_value_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetValueHighValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_value_high field + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryCustomTargetValueHigh(void) const + { + return GetFieldUINT32Value(22, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_value_high field + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetValueHigh(FIT_UINT32 secondaryCustomTargetValueHigh) + { + SetFieldUINT32Value(22, secondaryCustomTargetValueHigh, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_speed_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetSpeedHighValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_speed_high field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + FIT_FLOAT32 GetSecondaryCustomTargetSpeedHigh(void) const + { + return GetFieldFLOAT32Value(22, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_speed_high field + // Units: m/s + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetSpeedHigh(FIT_FLOAT32 secondaryCustomTargetSpeedHigh) + { + SetFieldFLOAT32Value(22, secondaryCustomTargetSpeedHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_SPEED_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_heart_rate_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetHeartRateHighValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_heart_rate_high field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_HR GetSecondaryCustomTargetHeartRateHigh(void) const + { + return GetFieldUINT32Value(22, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_heart_rate_high field + // Units: % or bpm + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetHeartRateHigh(FIT_WORKOUT_HR secondaryCustomTargetHeartRateHigh) + { + SetFieldUINT32Value(22, secondaryCustomTargetHeartRateHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_HEART_RATE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_cadence_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetCadenceHighValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_cadence_high field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + FIT_UINT32 GetSecondaryCustomTargetCadenceHigh(void) const + { + return GetFieldUINT32Value(22, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_cadence_high field + // Units: rpm + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetCadenceHigh(FIT_UINT32 secondaryCustomTargetCadenceHigh) + { + SetFieldUINT32Value(22, secondaryCustomTargetCadenceHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_CADENCE_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of secondary_custom_target_power_high field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsSecondaryCustomTargetPowerHighValid() const + { + const Field* field = GetField(22); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + if( !CanSupportSubField( field, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_POWER_HIGH ) ) + { + return FIT_FALSE; + } + + return field->IsValueValid(0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_POWER_HIGH); + } + + + /////////////////////////////////////////////////////////////////////// + // Returns secondary_custom_target_power_high field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + FIT_WORKOUT_POWER GetSecondaryCustomTargetPowerHigh(void) const + { + return GetFieldUINT32Value(22, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_POWER_HIGH); + } + + /////////////////////////////////////////////////////////////////////// + // Set secondary_custom_target_power_high field + // Units: % or watts + /////////////////////////////////////////////////////////////////////// + void SetSecondaryCustomTargetPowerHigh(FIT_WORKOUT_POWER secondaryCustomTargetPowerHigh) + { + SetFieldUINT32Value(22, secondaryCustomTargetPowerHigh, 0, (FIT_UINT16) Profile::WORKOUT_STEP_MESG_SECONDARY_CUSTOM_TARGET_VALUE_HIGH_FIELD_SECONDARY_CUSTOM_TARGET_POWER_HIGH); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_WORKOUT_STEP_MESG_HPP) diff --git a/fit_workout_step_mesg_listener.hpp b/fit_workout_step_mesg_listener.hpp new file mode 100644 index 0000000..70aa0dd --- /dev/null +++ b/fit_workout_step_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_WORKOUT_STEP_MESG_LISTENER_HPP) +#define FIT_WORKOUT_STEP_MESG_LISTENER_HPP + +#include "fit_workout_step_mesg.hpp" + +namespace fit +{ + +class WorkoutStepMesgListener +{ +public: + virtual ~WorkoutStepMesgListener() {} + virtual void OnMesg(WorkoutStepMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_WORKOUT_STEP_MESG_LISTENER_HPP) diff --git a/fit_zones_target_mesg.hpp b/fit_zones_target_mesg.hpp new file mode 100644 index 0000000..31c56a3 --- /dev/null +++ b/fit_zones_target_mesg.hpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ZONES_TARGET_MESG_HPP) +#define FIT_ZONES_TARGET_MESG_HPP + +#include "fit_mesg.hpp" + +namespace fit +{ + +class ZonesTargetMesg : public Mesg +{ +public: + class FieldDefNum final + { + public: + static const FIT_UINT8 MaxHeartRate = 1; + static const FIT_UINT8 ThresholdHeartRate = 2; + static const FIT_UINT8 FunctionalThresholdPower = 3; + static const FIT_UINT8 HrCalcType = 5; + static const FIT_UINT8 PwrCalcType = 7; + static const FIT_UINT8 Invalid = FIT_FIELD_NUM_INVALID; + }; + + ZonesTargetMesg(void) : Mesg(Profile::MESG_ZONES_TARGET) + { + } + + ZonesTargetMesg(const Mesg &mesg) : Mesg(mesg) + { + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of max_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsMaxHeartRateValid() const + { + const Field* field = GetField(1); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns max_heart_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetMaxHeartRate(void) const + { + return GetFieldUINT8Value(1, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set max_heart_rate field + /////////////////////////////////////////////////////////////////////// + void SetMaxHeartRate(FIT_UINT8 maxHeartRate) + { + SetFieldUINT8Value(1, maxHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of threshold_heart_rate field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsThresholdHeartRateValid() const + { + const Field* field = GetField(2); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns threshold_heart_rate field + /////////////////////////////////////////////////////////////////////// + FIT_UINT8 GetThresholdHeartRate(void) const + { + return GetFieldUINT8Value(2, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set threshold_heart_rate field + /////////////////////////////////////////////////////////////////////// + void SetThresholdHeartRate(FIT_UINT8 thresholdHeartRate) + { + SetFieldUINT8Value(2, thresholdHeartRate, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of functional_threshold_power field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsFunctionalThresholdPowerValid() const + { + const Field* field = GetField(3); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns functional_threshold_power field + /////////////////////////////////////////////////////////////////////// + FIT_UINT16 GetFunctionalThresholdPower(void) const + { + return GetFieldUINT16Value(3, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set functional_threshold_power field + /////////////////////////////////////////////////////////////////////// + void SetFunctionalThresholdPower(FIT_UINT16 functionalThresholdPower) + { + SetFieldUINT16Value(3, functionalThresholdPower, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of hr_calc_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsHrCalcTypeValid() const + { + const Field* field = GetField(5); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns hr_calc_type field + /////////////////////////////////////////////////////////////////////// + FIT_HR_ZONE_CALC GetHrCalcType(void) const + { + return GetFieldENUMValue(5, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set hr_calc_type field + /////////////////////////////////////////////////////////////////////// + void SetHrCalcType(FIT_HR_ZONE_CALC hrCalcType) + { + SetFieldENUMValue(5, hrCalcType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Checks the validity of pwr_calc_type field + // Returns FIT_TRUE if field is valid + /////////////////////////////////////////////////////////////////////// + FIT_BOOL IsPwrCalcTypeValid() const + { + const Field* field = GetField(7); + if( FIT_NULL == field ) + { + return FIT_FALSE; + } + + return field->IsValueValid(); + } + + /////////////////////////////////////////////////////////////////////// + // Returns pwr_calc_type field + /////////////////////////////////////////////////////////////////////// + FIT_PWR_ZONE_CALC GetPwrCalcType(void) const + { + return GetFieldENUMValue(7, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + /////////////////////////////////////////////////////////////////////// + // Set pwr_calc_type field + /////////////////////////////////////////////////////////////////////// + void SetPwrCalcType(FIT_PWR_ZONE_CALC pwrCalcType) + { + SetFieldENUMValue(7, pwrCalcType, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + +}; + +} // namespace fit + +#endif // !defined(FIT_ZONES_TARGET_MESG_HPP) diff --git a/fit_zones_target_mesg_listener.hpp b/fit_zones_target_mesg_listener.hpp new file mode 100644 index 0000000..e9db74c --- /dev/null +++ b/fit_zones_target_mesg_listener.hpp @@ -0,0 +1,30 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2025 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// +// ****WARNING**** This file is auto-generated! Do NOT edit this file. +// Profile Version = 21.188.1Release +// Tag = production/release/21.188.1-0-g5b0fbad +///////////////////////////////////////////////////////////////////////////////////////////// + + +#if !defined(FIT_ZONES_TARGET_MESG_LISTENER_HPP) +#define FIT_ZONES_TARGET_MESG_LISTENER_HPP + +#include "fit_zones_target_mesg.hpp" + +namespace fit +{ + +class ZonesTargetMesgListener +{ +public: + virtual ~ZonesTargetMesgListener() {} + virtual void OnMesg(ZonesTargetMesg& mesg) = 0; +}; + +} // namespace fit + +#endif // !defined(FIT_ZONES_TARGET_MESG_LISTENER_HPP) diff --git a/plugins/fit_hr_to_record_message_plugin.cpp b/plugins/fit_hr_to_record_message_plugin.cpp new file mode 100644 index 0000000..2f11788 --- /dev/null +++ b/plugins/fit_hr_to_record_message_plugin.cpp @@ -0,0 +1,252 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2023 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include "fit_file_id_mesg.hpp" +#include "fit_hr_mesg.hpp" +#include "fit_record_mesg.hpp" +#include "fit_runtime_exception.hpp" +#include "fit_session_mesg.hpp" +#include "fit_hr_to_record_message_plugin.hpp" + +namespace fit +{ + /** + * Provides functionality to backfill record messages with hr data from HR mesg. + *

+ * The plugin matches the timestamp of record messages with the timestamps hr data + * contained in the HR mesg. + *

+ * Requirements for correct operation: + * - HR data must be in the order of increasing timestamp + * - Record data must be in the order of increasing timestamp + * - The order of incoming HR and record mesgs may be independent of each other + * - The first HR mesg must contain a timestamp (with optional fractional_timestamp) + * which, in combination with the event_timestamps that mark the bpm data, provide the + * time that is used to match record data. + * - There must be an equal number of filtered_bpm fields and event_timestamp fields in each + * HR mesg; this number may change from message to message. + * + */ + HRToRecordMesgBroadcastPlugin::HRToRecordMesgBroadcastPlugin() + { + record_range_start_time = new DateTime((FIT_DATE_TIME)0); + hr_start_index = INVALID_INDEX; + hr_start_sub_index = INVALID_INDEX; + isActivityFile = FIT_FALSE; + mesg_count = 0; + + hr_mesgs = 0; + record_mesgs = 0; + } + + HRToRecordMesgBroadcastPlugin::~HRToRecordMesgBroadcastPlugin() + { + if (record_range_start_time != NULL) + delete record_range_start_time; + } + /** + * Peeks messages as they are being added to the buffer + * + * @param mesg the message that has just been buffered by BufferedMesgBroadcaster + */ + void HRToRecordMesgBroadcastPlugin::OnIncomingMesg(const Mesg& mesg) + { + switch (mesg.GetNum()) + { + + case FIT_MESG_NUM_FILE_ID: + { + // Check to see if we are processing an activity file. + FileIdMesg fileIdMesg = FileIdMesg(mesg); + if (fileIdMesg.GetType() == FIT_FILE_ACTIVITY) + isActivityFile = true; + } + break; + + case FIT_MESG_NUM_SESSION: + { + // Obtain session start time to mark the start of the first + // record message's time range + SessionMesg sessionMesg = SessionMesg(mesg); + record_range_start_time = new DateTime(sessionMesg.GetStartTime()); + } + break; + + case FIT_MESG_NUM_HR: + hr_mesgs++; + if (hr_start_index == INVALID_INDEX) + { + // Mark the first appearance of an HR message + hr_start_index = mesg_count; + hr_start_sub_index = 0; + } + break; + + case FIT_MESG_NUM_RECORD: + record_mesgs++; + break; + + default: + break; + + } // switch + + mesg_count++; + } + /** + * Matches record time ranges with all time matching HR mesgs and updates the + * message stream for later broadcast to listeners. + * + * @param mesgs the message list that is about to be broadcast to all MesgListeners. \ + Note: The List is 'final' but the references within the list are not, \ + therefore editing Mesg objects within mesgs will alter the messages \ + that are broadcast to listeners. + * + * DO NOT add or remove any messages to mesgs + */ + void HRToRecordMesgBroadcastPlugin::OnBroadcast(std::vector& mesgs) + { + // Check if we have an activity file and have received HR messages + if (isActivityFile && (hr_start_index != INVALID_INDEX)) + { + FIT_FLOAT32 hr_anchor_event_timestamp = 0.0; + DateTime hr_anchor_timestamp = DateTime((FIT_DATE_TIME)0); + FIT_BOOL hr_anchor_set = FIT_FALSE; + FIT_UINT8 last_valid_hr = 0; + DateTime last_valid_hr_time = DateTime((FIT_DATE_TIME)0); + + for (FIT_UINT32 mesgCounter = 0; mesgCounter < mesgs.size(); ++mesgCounter) + { + Mesg &mesg = mesgs.at(mesgCounter); + + // Process any record messages we encounter + if (mesg.GetNum() == FIT_MESG_NUM_RECORD) + { + FIT_FLOAT32 hrSum = 0; + FIT_FLOAT32 hrSumCount = 0; + + // Obtain the time for which the record message is valid + FIT_DATE_TIME timestamp = mesg.GetFieldUINT32Value(253, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + DateTime record_range_end_time = DateTime(timestamp); + + // Need to determine timestamp range which applies to this record + FIT_BOOL findingInRangeHrMesgs = FIT_TRUE; + + // Start searching HR mesgs where we left off + FIT_UINT32 hr_mesg_counter = hr_start_index; + FIT_UINT32 hr_sub_mesg_counter = hr_start_sub_index; + + while (findingInRangeHrMesgs && (hr_mesg_counter < mesgs.size())) + { + // Skip over any non HR messages + if (mesgs.at(hr_mesg_counter).GetNum() == FIT_MESG_NUM_HR) + { + HrMesg hrMesg = HrMesg(mesgs.at(hr_mesg_counter)); + + // Update HR timestamp anchor, if present + if (hrMesg.GetTimestamp() != FIT_UINT32_INVALID) + { + hr_anchor_timestamp = DateTime(hrMesg.GetTimestamp()); + hr_anchor_set = FIT_TRUE; + + FIT_FLOAT32 fractionalTimestamp = hrMesg.GetFractionalTimestamp(); + if (memcmp(&fractionalTimestamp, &FIT_FLOAT32_INVALID, sizeof(FIT_FLOAT32)) != 0) + hr_anchor_timestamp.add(fractionalTimestamp); + + if (hrMesg.GetNumEventTimestamp() == 1) + { + hr_anchor_event_timestamp = hrMesg.GetEventTimestamp(0); + } + else + { + throw RuntimeException("FIT HrToRecordMesgBroadcastPlugin Error: Anchor HR mesg must have 1 event_timestamp"); + } + } + + if (hr_anchor_set == FIT_FALSE) + { + // We cannot process any HR messages if we have not received a timestamp anchor + throw RuntimeException("FIT HrToRecordMesgBroadcastPlugin Error: No anchor timestamp received in a HR mesg before diff HR mesgs"); + } + else if (hrMesg.GetNumEventTimestamp() != hrMesg.GetNumFilteredBpm()) + { + throw RuntimeException("FIT HrToRecordMesgBroadcastPlugin Error: HR mesg with mismatching event timestamp and filtered bpm"); + } + + for (FIT_UINT8 j = (FIT_UINT8)hr_sub_mesg_counter; j < hrMesg.GetNumEventTimestamp(); j++) + { + // Build up timestamp for each message using the anchor and event_timestamp + DateTime hrMesgTime = DateTime(hr_anchor_timestamp); + FIT_FLOAT32 event_timestamp = hrMesg.GetEventTimestamp(j); + + // Deal with roll over case + if (event_timestamp < hr_anchor_event_timestamp) + { + if ((hr_anchor_event_timestamp - event_timestamp) > (1 << 21)) + { + event_timestamp += (1 << 22); + } + else + { + throw RuntimeException("FIT HrToRecordMesgBroadcastPlugin Error: Anchor event_timestamp is greater than subsequent event_timestamp. This does not allow for correct delta calculation."); + } + } + + hrMesgTime.add(event_timestamp - hr_anchor_event_timestamp); + + // Check if hrMesgTime is gt record start time + // and if hrMesgTime is lte to record end time + if ((hrMesgTime.CompareTo(*record_range_start_time) > 0) && + (hrMesgTime.CompareTo(record_range_end_time) <= 0)) + { + hrSum += hrMesg.GetFilteredBpm(j); + hrSumCount++; + last_valid_hr_time = hrMesgTime; + } + // check if hrMesgTime exceeds the record time + else if (hrMesgTime.CompareTo(record_range_end_time) > 0) + { + // Remember where we left off + hr_start_index = hr_mesg_counter; + hr_start_sub_index = j; + findingInRangeHrMesgs = false; + + if (hrSumCount > 0) + { + // Update record heart rate + last_valid_hr = (FIT_UINT8)round(((float)hrSum) / hrSumCount); + mesg.SetFieldUINT8Value(3, last_valid_hr, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + // If no stored HR is available, fill in record messages with the + // last valid filtered hr for a maximum of 5 seconds + else if ((record_range_start_time->CompareTo(last_valid_hr_time) > 0) && + ((record_range_start_time->GetTimeStamp() - last_valid_hr_time.GetTimeStamp()) < 5)) + { + mesg.SetFieldUINT8Value(3, last_valid_hr, 0, FIT_SUBFIELD_INDEX_MAIN_FIELD); + } + + // Reset HR average + hrSum = 0; + hrSumCount = 0; + + record_range_start_time = new DateTime(record_range_end_time); + + // Breaks out of looping within the event_timestamp array + break; + } + } + } + hr_mesg_counter++; + hr_sub_mesg_counter = 0; + } // while + } + }// for + } + } + +} // namespace fit diff --git a/plugins/fit_hr_to_record_message_plugin.hpp b/plugins/fit_hr_to_record_message_plugin.hpp new file mode 100644 index 0000000..b4ff56e --- /dev/null +++ b/plugins/fit_hr_to_record_message_plugin.hpp @@ -0,0 +1,46 @@ +///////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2023 Garmin International, Inc. +// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you +// may not use this file except in compliance with the Flexible and Interoperable Data +// Transfer (FIT) Protocol License. +///////////////////////////////////////////////////////////////////////////////////////////// + +#if !defined(FIT_HR_TO_RECORD_MESSAGE_PLUGIN_HPP) +#define FIT_HR_TO_RECORD_MESSAGE_PLUGIN_HPP + +#include "fit.hpp" +#include "fit_date_time.hpp" +#include "fit_mesg_broadcast_plugin.hpp" +#include + +namespace fit +{ + +class HRToRecordMesgBroadcastPlugin : public fit::MesgBroadcastPlugin +{ + public: + HRToRecordMesgBroadcastPlugin(); + ~HRToRecordMesgBroadcastPlugin(); + void OnBroadcast(std::vector& mesgs); + void OnIncomingMesg(const Mesg& mesg); + // Plugins are not designed to be copied + HRToRecordMesgBroadcastPlugin &operator=(const HRToRecordMesgBroadcastPlugin&) = delete; + HRToRecordMesgBroadcastPlugin(const HRToRecordMesgBroadcastPlugin&) = delete; + + FIT_UINT32 GetHRMesgs() { return hr_mesgs; }; + FIT_UINT32 GetRecordMesgs() { return record_mesgs; }; + + private: + DateTime *record_range_start_time; + FIT_SINT32 hr_start_index; + FIT_SINT32 hr_start_sub_index; + FIT_BOOL isActivityFile; + FIT_UINT32 mesg_count; + const FIT_SINT32 INVALID_INDEX = -1; + FIT_UINT32 hr_mesgs; + FIT_UINT32 record_mesgs; +}; + +} // namespace fit + +#endif // defined(FIT_HR_TO_RECORD_MESSAGE_PLUGIN_HPP)