├── src ├── CommonDataPages │ ├── ANTPLUS_CommandStatus.cpp │ ├── ANTPLUS_GenericCommand.cpp │ ├── ANTPLUS_MemoryLevel.cpp │ ├── ANTPLUS_PairedDevices.cpp │ ├── ANTPLUS_SubfieldData.cpp │ ├── ANTPLUS_TimeAndDate.cpp │ ├── ANTPLUS_ANTFSClientBeacon.cpp │ ├── ANTPLUS_ErrorDescription.cpp │ ├── ANTPLUS_OpenChannelCommand.cpp │ ├── ANTPLUS_CommandStatus.h │ ├── ANTPLUS_GenericCommand.h │ ├── ANTPLUS_MemoryLevel.h │ ├── ANTPLUS_PairedDevices.h │ ├── ANTPLUS_SubfieldData.h │ ├── ANTPLUS_TimeAndDate.h │ ├── ANTPLUS_ANTFSClientBeacon.h │ ├── ANTPLUS_ErrorDescription.h │ ├── ANTPLUS_OpenChannelCommand.h │ ├── ANTPLUS_ModeSettings.h │ ├── ANTPLUS_CommonDataPages.h │ ├── ANTPLUS_ProductInformation.h │ ├── ANTPLUS_ManufacturersInformation.h │ ├── ANTPLUS_ModeSettings.cpp │ ├── ANTPLUS_BatteryStatus.h │ ├── ANTPLUS_MultiComponentSystemProductInformation.h │ ├── ANTPLUS_MultiComponentSystemManufacturersInformation.h │ ├── ANTPLUS_RequestDataPage.h │ ├── ANTPLUS_ProductInformation.cpp │ ├── ANTPLUS_ManufacturersInformation.cpp │ └── ANTPLUS_CommonDataPageDefines.h ├── Profiles │ ├── Shifting │ │ ├── Profiles │ │ │ └── ANTPLUS_ProfileShiftingDisplay.cpp │ │ ├── ANTPLUS_ProfileShiftingDataPages.h │ │ ├── ANTPLUS_ShiftingProfile.h │ │ ├── ANTPLUS_ShiftingPrivateDefines.h │ │ ├── DataPages │ │ │ ├── ANTPLUS_ShiftingBaseMainDataPage.cpp │ │ │ ├── ANTPLUS_ShiftingBaseMainDataPage.h │ │ │ └── ANTPLUS_ShiftingShiftSystemStatus.h │ │ └── ANTPLUS_ShiftingDefines.h │ ├── BicycleSpeed │ │ ├── DataPages │ │ │ ├── ANTPLUS_BicycleSpeedDefault.cpp │ │ │ ├── ANTPLUS_BicycleSpeedDefault.h │ │ │ ├── ANTPLUS_BicycleSpeedMotionAndSpeed.h │ │ │ ├── ANTPLUS_BicycleSpeedManufacturerID.h │ │ │ ├── ANTPLUS_BicycleSpeedProductID.h │ │ │ ├── ANTPLUS_BicycleSpeedBatteryStatus.h │ │ │ ├── ANTPLUS_BicycleSpeedCumulativeOperatingTime.h │ │ │ ├── ANTPLUS_BicycleSpeedMotionAndSpeed.cpp │ │ │ ├── ANTPLUS_BicycleSpeedCumulativeOperatingTime.cpp │ │ │ ├── ANTPLUS_BicycleSpeedManufacturerID.cpp │ │ │ ├── ANTPLUS_BicycleSpeedProductID.cpp │ │ │ ├── ANTPLUS_BicycleSpeedBaseMainDataPage.h │ │ │ ├── ANTPLUS_BicycleSpeedBatteryStatus.cpp │ │ │ └── ANTPLUS_BicycleSpeedBaseMainDataPage.cpp │ │ ├── ANTPLUS_BicycleSpeedPrivateDefines.h │ │ ├── ANTPLUS_BicycleSpeedProfile.h │ │ ├── ANTPLUS_BicycleSpeedDataPages.h │ │ ├── ANTPLUS_BicycleSpeedDefines.h │ │ └── Profiles │ │ │ ├── ANTPLUS_ProfileBicycleSpeedSensor.h │ │ │ └── ANTPLUS_ProfileBicycleSpeedDisplay.h │ ├── Lev │ │ ├── ANTPLUS_LevPrivateDefines.h │ │ ├── ANTPLUS_LevProfile.h │ │ ├── DataPages │ │ │ ├── ANTPLUS_LevBaseMainDataPage.cpp │ │ │ ├── ANTPLUS_LevBaseMainDataPage.h │ │ │ ├── ANTPLUS_LevSpeedDistanceInformation.h │ │ │ ├── ANTPLUS_LevAltSpeedDistanceInformation.h │ │ │ ├── ANTPLUS_LevCapabilities.h │ │ │ ├── ANTPLUS_LevBaseSpeedDistanceInformation.h │ │ │ ├── ANTPLUS_LevSpeedSystemInformation2.h │ │ │ ├── ANTPLUS_LevBatteryInformation.h │ │ │ ├── ANTPLUS_LevSpeedSystemInformation1.h │ │ │ ├── ANTPLUS_LevSpeedDistanceInformation.cpp │ │ │ ├── ANTPLUS_LevAltSpeedDistanceInformation.cpp │ │ │ ├── ANTPLUS_LevBaseSpeedSystemInformation.h │ │ │ ├── ANTPLUS_LevBaseSpeedDistanceInformation.cpp │ │ │ ├── ANTPLUS_LevDisplayData.h │ │ │ ├── ANTPLUS_LevSpeedSystemInformation2.cpp │ │ │ └── ANTPLUS_LevCapabilities.cpp │ │ ├── ANTPLUS_LevDataPages.h │ │ └── Profiles │ │ │ └── ANTPLUS_ProfileLevDisplay.h │ ├── Environment │ │ ├── DataPages │ │ │ ├── ANTPLUS_EnvironmentBaseDataPage.cpp │ │ │ ├── ANTPLUS_EnvironmentBaseDataPage.h │ │ │ ├── ANTPLUS_EnvironmentTemperature.h │ │ │ ├── ANTPLUS_EnvironmentGeneralInformation.h │ │ │ ├── ANTPLUS_EnvironmentGeneralInformation.cpp │ │ │ └── ANTPLUS_EnvironmentTemperature.cpp │ │ ├── ANTPLUS_EnvironmentDataPages.h │ │ ├── ANTPLUS_EnvironmentPrivateDefines.h │ │ ├── ANTPLUS_EnvironmentProfile.h │ │ ├── Profiles │ │ │ ├── ANTPLUS_ProfileEnvironmentMonitor.h │ │ │ └── ANTPLUS_ProfileEnvironmentDisplay.h │ │ └── ANTPLUS_EnvironmentDefines.h │ ├── MuscleOxygen │ │ ├── ANTPLUS_ProfileMuscleOxygenDataPages.h │ │ ├── ANTPLUS_MuscleOxygenPrivateDefines.h │ │ ├── ANTPLUS_MuscleOxygenProfile.h │ │ ├── DataPages │ │ │ ├── ANTPLUS_MuscleOxygenBaseMainDataPage.cpp │ │ │ ├── ANTPLUS_MuscleOxygenBaseMainDataPage.h │ │ │ ├── ANTPLUS_MuscleOxygenCommands.h │ │ │ ├── ANTPLUS_MuscleOxygenMuscleOxygenData.h │ │ │ └── ANTPLUS_MuscleOxygenCommands.cpp │ │ ├── ANTPLUS_MuscleOxygenDefines.h │ │ └── Monitor │ │ │ ├── ANTPLUS_ProfileMuscleOxygenMonitor.h │ │ │ └── ANTPLUS_ProfileMuscleOxygenMonitor.cpp │ ├── Fec │ │ ├── ANTPLUS_FecProfile.h │ │ ├── DataPages │ │ │ ├── ANTPLUS_FecBaseMainDataPage.cpp │ │ │ ├── ANTPLUS_FecBaseMainDataPage.h │ │ │ ├── ANTPLUS_FecTargetPower.h │ │ │ ├── ANTPLUS_FecBasicResistance.h │ │ │ ├── ANTPLUS_FecTrackResistance.h │ │ │ ├── ANTPLUS_FecFeCapabilities.h │ │ │ ├── ANTPLUS_FecUserConfiguration.h │ │ │ ├── ANTPLUS_FecGeneralSettingsPage.h │ │ │ ├── ANTPLUS_FecTargetPower.cpp │ │ │ ├── ANTPLUS_FecBasicResistance.cpp │ │ │ ├── ANTPLUS_FecGeneralFeData.h │ │ │ ├── ANTPLUS_FecSpecificTrainerData.h │ │ │ ├── ANTPLUS_FecTrackResistance.cpp │ │ │ ├── ANTPLUS_FecGeneralSettingsPage.cpp │ │ │ └── ANTPLUS_FecFeCapabilities.cpp │ │ ├── ANTPLUS_FecDataPages.h │ │ ├── ANTPLUS_FecPrivateDefines.h │ │ └── Profiles │ │ │ └── ANTPLUS_FecProfileDisplay.h │ ├── BicyclePower │ │ ├── ANTPLUS_BicyclePowerPrivateDefines.h │ │ ├── ANTPLUS_BicyclePowerProfile.h │ │ ├── ANTPLUS_BicyclePowerDataPages.h │ │ ├── DataPages │ │ │ ├── ANTPLUS_BicyclePowerBaseMainDataPage.h │ │ │ ├── ANTPLUS_BicyclePowerBaseMainDataPage.cpp │ │ │ ├── ANTPLUS_BicyclePowerCrankTorqueFrequency.h │ │ │ ├── ANTPLUS_BicyclePowerStandardCrankTorque.h │ │ │ ├── ANTPLUS_BicyclePowerStandardWheelTorque.h │ │ │ ├── ANTPLUS_BicyclePowerStandardPowerOnly.h │ │ │ ├── ANTPLUS_BicyclePowerTorqueEffectivenessAndPedalSmoothness.h │ │ │ ├── ANTPLUS_BicyclePowerCrankTorqueFrequency.cpp │ │ │ ├── ANTPLUS_BicyclePowerStandardCrankTorque.cpp │ │ │ └── ANTPLUS_BicyclePowerStandardWheelTorque.cpp │ │ └── ANTPLUS_BicyclePowerDefines.h │ ├── HeartRate │ │ ├── ANTPLUS_HeartRateProfile.h │ │ ├── DataPages │ │ │ ├── ANTPLUS_HeartRateDefault.h │ │ │ ├── ANTPLUS_HeartRateDefault.cpp │ │ │ ├── ANTPLUS_HeartRateCapabilities.h │ │ │ ├── ANTPLUS_HeartRateCumulativeOperatingTime.h │ │ │ ├── ANTPLUS_HeartRatePreviousHeartBeat.h │ │ │ ├── ANTPLUS_HeartRateManufacturerInformation.h │ │ │ ├── ANTPLUS_HeartRateProductInformation.h │ │ │ ├── ANTPLUS_HeartRateBatteryStatus.h │ │ │ ├── ANTPLUS_HeartRateSwimIntervalSummary.h │ │ │ ├── ANTPLUS_HeartRateCumulativeOperatingTime.cpp │ │ │ ├── ANTPLUS_HeartRateBaseMainDataPage.h │ │ │ ├── ANTPLUS_HeartRateCapabilities.cpp │ │ │ ├── ANTPLUS_HeartRateManufacturerInformation.cpp │ │ │ ├── ANTPLUS_HeartRateProductInformation.cpp │ │ │ ├── ANTPLUS_HeartRatePreviousHeartBeat.cpp │ │ │ ├── ANTPLUS_HeartRateSwimIntervalSummary.cpp │ │ │ ├── ANTPLUS_HeartRateBatteryStatus.cpp │ │ │ └── ANTPLUS_HeartRateBaseMainDataPage.cpp │ │ ├── ANTPLUS_HeartRatePrivateDefines.h │ │ ├── ANTPLUS_HeartRateDataPages.h │ │ └── ANTPLUS_HeartRateDefines.h │ └── ANTPLUS_Profiles.h ├── ANTPLUS.h ├── BaseClasses │ ├── ANTPLUS_BaseSlaveProfile.h │ ├── ANTPLUS_BaseSlaveProfile.cpp │ ├── ANTPLUS_CoreDataPage.cpp │ ├── ANTPLUS_BaseDataPage.h │ ├── ANTPLUS_CoreDataPage.h │ ├── ANTPLUS_BaseDataPageMsg.h │ ├── ANTPLUS_BaseDataPage.cpp │ ├── ANTPLUS_BaseMasterProfile.h │ └── ANTPLUS_BaseMasterProfile.cpp ├── ANTPLUS_Defines.h ├── ANTPLUS_PrivateDefines.h └── MainClasses │ └── ANTPLUS_CallbackWorkAround.h ├── .bettercodehub.yml ├── examples ├── LEVDisplay │ └── LEVDisplay.ino ├── ShiftingShifter │ └── ShiftingShifter.ino ├── MuscleOxygenMonitor │ └── MuscleOxygenMonitor.ino └── DeviceSearch │ └── DeviceSearch.ino ├── .gitignore ├── test ├── test_basedatapage │ ├── BaseDataPageTests.h │ ├── runner.cpp │ └── Test_BaseDataPage.cpp └── test_heart-rate-display │ └── Test_HeartRateDisplayDefaultDataPage.cpp ├── library.properties ├── library.json └── platformio.ini /src/CommonDataPages/ANTPLUS_CommandStatus.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_GenericCommand.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_MemoryLevel.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_PairedDevices.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_SubfieldData.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_TimeAndDate.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ANTFSClientBeacon.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ErrorDescription.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_OpenChannelCommand.cpp: -------------------------------------------------------------------------------- 1 | // TODO -------------------------------------------------------------------------------- /.bettercodehub.yml: -------------------------------------------------------------------------------- 1 | component_depth: 2 2 | languages: 3 | - cpp 4 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_CommandStatus.h: -------------------------------------------------------------------------------- 1 | // Common Page 71 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_GenericCommand.h: -------------------------------------------------------------------------------- 1 | // Common page 73 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_MemoryLevel.h: -------------------------------------------------------------------------------- 1 | // Common Page 85 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_PairedDevices.h: -------------------------------------------------------------------------------- 1 | // Common Page 86 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_SubfieldData.h: -------------------------------------------------------------------------------- 1 | // Common Page 84 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_TimeAndDate.h: -------------------------------------------------------------------------------- 1 | // Common Page 83 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ANTFSClientBeacon.h: -------------------------------------------------------------------------------- 1 | // Common Page 67 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ErrorDescription.h: -------------------------------------------------------------------------------- 1 | // Common Page 87 2 | // TODO -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_OpenChannelCommand.h: -------------------------------------------------------------------------------- 1 | // Common Page 74 2 | // TODO -------------------------------------------------------------------------------- /examples/LEVDisplay/LEVDisplay.ino: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cujomalainey/antplus-arduino/HEAD/examples/LEVDisplay/LEVDisplay.ino -------------------------------------------------------------------------------- /examples/ShiftingShifter/ShiftingShifter.ino: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cujomalainey/antplus-arduino/HEAD/examples/ShiftingShifter/ShiftingShifter.ino -------------------------------------------------------------------------------- /src/Profiles/Shifting/Profiles/ANTPLUS_ProfileShiftingDisplay.cpp: -------------------------------------------------------------------------------- 1 | #define ANTPLUS_SHIFTING_DISPLAY_CHANNELTYPE CHANNEL_TYPE_BIDIRECTIONAL_RECEIVE 2 | -------------------------------------------------------------------------------- /examples/MuscleOxygenMonitor/MuscleOxygenMonitor.ino: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cujomalainey/antplus-arduino/HEAD/examples/MuscleOxygenMonitor/MuscleOxygenMonitor.ino -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .pioenvs 2 | .piolibdeps 3 | .ycm* 4 | *.swp 5 | *.DS_Store 6 | 7 | # used for testing 8 | src/main.cpp 9 | 10 | .DS_Store 11 | .tags* 12 | tags 13 | .pio 14 | *-e 15 | -------------------------------------------------------------------------------- /test/test_basedatapage/BaseDataPageTests.h: -------------------------------------------------------------------------------- 1 | #ifndef BASEDATAPAGETEST_h 2 | #define BASEDATAPAGETEST_h 3 | 4 | void runBaseDataPageTests(); 5 | void runBaseDataPageMsgTests(); 6 | 7 | #endif // BASEDATAPAGETEST_h 8 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedDefault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | BicycleSpeedDefault::BicycleSpeedDefault(AntRxDataResponse& dp) : BicycleSpeedBaseMainDataPage(dp) { 4 | } 5 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/ANTPLUS_ProfileShiftingDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILESHIFTINGDATAPAGES_h 2 | #define ANTPLUS_PROFILESHIFTINGDATAPAGES_h 3 | 4 | #include 5 | 6 | #endif // ANTPLUS_PROFILESHIFTINGDATAPAGES_h 7 | -------------------------------------------------------------------------------- /src/ANTPLUS.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_h 2 | #define ANTPLUS_h 3 | 4 | // Management Classes 5 | #include 6 | 7 | // Common Data Pages 8 | #include 9 | 10 | // Profiles 11 | #include 12 | 13 | #endif // ANTPLUS_h 14 | -------------------------------------------------------------------------------- /src/Profiles/Lev/ANTPLUS_LevPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_LEVPROFILEPRIVATEDEFINES_h 3 | 4 | /* Channel Config */ 5 | #define LEV_CHANNELPERIOD 8192 6 | // 30 / 2.5 = 12 7 | #define LEV_SEARCHTIMEOUT 12 8 | 9 | #endif // ANTPLUS_BICYCLESPEEDPROFILEPRIVATEDEFINES_h 10 | -------------------------------------------------------------------------------- /src/Profiles/Environment/DataPages/ANTPLUS_EnvironmentBaseDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | EnvironmentBaseDataPage::EnvironmentBaseDataPage(AntRxDataResponse& dp) : 5 | BaseDataPage(dp) {} 6 | -------------------------------------------------------------------------------- /src/Profiles/Environment/ANTPLUS_EnvironmentDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEENVIRONMENTDATAPAGES_h 2 | #define ANTPLUS_PROFILEENVIRONMENTDATAPAGES_h 3 | 4 | #include 5 | #include 6 | 7 | #endif // ANTPLUS_PROFILEENVIRONMENTDATAPAGES_h 8 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/ANTPLUS_ProfileMuscleOxygenDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEMUSCLEOXYGENDATAPAGES_h 2 | #define ANTPLUS_PROFILEMUSCLEOXYGENDATAPAGES_h 3 | 4 | #include 5 | #include 6 | 7 | #endif // ANTPLUS_PROFILEMUSCLEOXYGENDATAPAGES_h 8 | -------------------------------------------------------------------------------- /src/Profiles/Lev/ANTPLUS_LevProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVPROFILE_h 2 | #define ANTPLUS_LEVPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | 13 | #endif // ANTPLUS_LEVPROFILE_h 14 | -------------------------------------------------------------------------------- /test/test_basedatapage/runner.cpp: -------------------------------------------------------------------------------- 1 | #include "unity.h" 2 | #include "Util/Testing.h" 3 | #include "ANTPLUS.h" 4 | #include "BaseDataPageTests.h" 5 | 6 | #ifdef UNIT_TEST 7 | 8 | 9 | int main(int argc, char **argv) { 10 | 11 | UNITY_BEGIN(); 12 | runBaseDataPageTests(); 13 | runBaseDataPageMsgTests(); 14 | UNITY_END(); 15 | 16 | return 0; 17 | } 18 | 19 | #endif // UNIT_TEST 20 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/ANTPLUS_MuscleOxygenPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MUSCLEOXYGENPRIVATEDEFINES_h 2 | #define ANTPLUS_MUSCLEOXYGENPRIVATEDEFINES_h 3 | 4 | #include 5 | 6 | // Master channel 7 | #define MUSCLEOXYGEN_CHANNELPERIOD 8192 8 | 9 | // 30 / 2.5 = 12 10 | #define MUSCLEOXYGEN_SEARCHTIMEOUT 12 11 | 12 | #endif // ANTPLUS_MUSCLEOXYGENPRIVATEDEFINES_h 13 | -------------------------------------------------------------------------------- /src/Profiles/Environment/ANTPLUS_EnvironmentPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_ENVIRONMENTPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_ENVIRONMENTPROFILEPRIVATEDEFINES_h 3 | 4 | #include 5 | 6 | /* Channel Config */ 7 | #define ENVIRONMENT_CHANNELPERIOD 8192 8 | // 45 / 2.5 = 18 9 | #define ENVIRONMENT_SEARCHTIMEOUT 18 10 | 11 | #endif // ANTPLUS_ENVIRONMENTPROFILEPRIVATEDEFINES_h 12 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/ANTPLUS_BicycleSpeedPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_BICYCLESPEEDPROFILEPRIVATEDEFINES_h 3 | 4 | #include 5 | 6 | /* Channel Config */ 7 | #define BICYCLESPEED_CHANNELPERIOD 8118 8 | // 30 / 2.5 = 12 9 | #define BICYCLESPEED_SEARCHTIMEOUT 12 10 | 11 | #endif // ANTPLUS_BICYCLESPEEDPROFILEPRIVATEDEFINES_h 12 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedDefault.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDDEFAULT_h 2 | #define ANTPLUS_BICYCLESPEEDDEFAULT_h 3 | 4 | #include 5 | 6 | class BicycleSpeedDefault : public BicycleSpeedBaseMainDataPage { 7 | public: 8 | explicit BicycleSpeedDefault(AntRxDataResponse& dp); 9 | }; 10 | 11 | #endif // ANTPLUS_BICYCLESPEEDDEFAULT_h 12 | -------------------------------------------------------------------------------- /src/Profiles/Environment/DataPages/ANTPLUS_EnvironmentBaseDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_ENVIRONMENTBASEMAINDATAPAGE_h 2 | #define ANTPLUS_ENVIRONMENTBASEMAINDATAPAGE_h 3 | 4 | #include 5 | 6 | class EnvironmentBaseDataPage : public BaseDataPage { 7 | public: 8 | explicit EnvironmentBaseDataPage(AntRxDataResponse& dp); 9 | }; 10 | 11 | #endif // ANTPLUS_ENVIRONMENTBASEMAINDATAPAGE_h 12 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/ANTPLUS_ShiftingProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_SHIFTINGPROFILE_h 2 | #define ANTPLUS_SHIFTINGPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | 13 | #endif // ANTPLUS_SHIFTINGPROFILE_h 14 | -------------------------------------------------------------------------------- /src/Profiles/Fec/ANTPLUS_FecProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECPROFILE_h 2 | #define ANTPLUS_FECPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | // #include 13 | 14 | #endif // ANTPLUS_FECPROFILE_h 15 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/ANTPLUS_BicyclePowerPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_BICYCLEPOWERPROFILEPRIVATEDEFINES_h 3 | 4 | #include 5 | 6 | /* Channel Config */ 7 | #define BICYCLEPOWER_CHANNELPERIOD 8182 8 | // 30 / 2.5 = 12 9 | #define BICYCLEPOWER_SEARCHTIMEOUT 12 10 | 11 | #endif // ANTPLUS_BICYCLEPOWERPROFILEPRIVATEDEFINES_h 12 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/ANTPLUS_MuscleOxygenProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MUSCLEOXYGENPROFILE_h 2 | #define ANTPLUS_MUSCLEOXYGENPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | 13 | #endif // ANTPLUS_MUSCLEOXYGENPROFILE_h 14 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/ANTPLUS_ShiftingPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_SHIFTINGPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_SHIFTINGPROFILEPRIVATEDEFINES_h 3 | 4 | /* Channel Config */ 5 | #define SHIFTING_CHANNELPERIOD 8192 6 | // 30 / 2.5 = 12 7 | #define SHIFTING_SEARCHTIMEOUT 12 8 | 9 | // Transmission pattern math 10 | #define ANTPLUS_SHIFTING_BACKGROUNDPAGE_INTERLEAVEINTERVAL 260 11 | #define ANTPLUS_SHIFTING_NUMBERBACKGROUNDPAGES_PERCOMPONENT 3 12 | 13 | #endif // ANTPLUS_SHIFTINGPROFILEPRIVATEDEFINES_h 14 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | FecBaseMainDataPage::FecBaseMainDataPage(AntRxDataResponse& dp) : 5 | BaseDataPage(dp) {} 6 | 7 | FecBaseMainDataPageMsg::FecBaseMainDataPageMsg(uint8_t dataPageNumber) : 8 | BaseDataPageMsg() { 9 | setDataBuffer(_buffer); 10 | set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 11 | } 12 | 13 | -------------------------------------------------------------------------------- /library.properties: -------------------------------------------------------------------------------- 1 | name=ANTPLUS-Arduino 2 | version=1.2.0 3 | author=Curtis Malainey 4 | maintainer=Curtis Malainey 5 | sentence=Library for easy ANT+ integration 6 | paragraph=Implements the ANT+ network on top the ANT driver for communication with ANT+ devices. Enables support for integration into various sports sensors/devices. 7 | category=Communication 8 | url=https://github.com/cujomalainey/antplus-arduino 9 | architectures=* 10 | includes=ANTPLUS.h 11 | depends=ANT-Arduino 12 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseSlaveProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BASESLAVEPROFILE_h 2 | #define ANTPLUS_BASESLAVEPROFILE_h 3 | 4 | #include 5 | 6 | class BaseSlaveProfile : public BaseProfile { 7 | public: 8 | explicit BaseSlaveProfile(uint16_t deviceNumber = 0, uint8_t transmissionType = 0); 9 | /** 10 | * Will return once the device either pairs or timesout its search 11 | */ 12 | uint8_t waitForPair(); 13 | private: 14 | }; 15 | 16 | #endif // ANTPLUS_BASESLAVEPROFILE_h 17 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/ANTPLUS_HeartRateProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEPROFILE_h 2 | #define ANTPLUS_HEARTRATEPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | #include 13 | 14 | #endif // ANTPLUS_HEARTRATEPROFILE_h 15 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateDefault.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEDEFAULT_h 2 | #define ANTPLUS_HEARTRATEDEFAULT_h 3 | 4 | #include 5 | 6 | class HeartRateDefault : public HeartRateBaseMainDataPage { 7 | public: 8 | explicit HeartRateDefault(AntRxDataResponse& dp); 9 | }; 10 | 11 | class HeartRateDefaultMsg : public HeartRateBaseMainDataPageMsg { 12 | public: 13 | HeartRateDefaultMsg(); 14 | }; 15 | 16 | #endif // ANTPLUS_HEARTRATEDEFAULT_h 17 | -------------------------------------------------------------------------------- /src/Profiles/Environment/ANTPLUS_EnvironmentProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_ENVIRONMENTPROFILE_h 2 | #define ANTPLUS_ENVIRONMENTPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | #include 13 | 14 | #endif // ANTPLUS_ENVIRONMENTPROFILE_h 15 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/DataPages/ANTPLUS_MuscleOxygenBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | MuscleOxygenBaseMainDataPage::MuscleOxygenBaseMainDataPage(AntRxDataResponse& dp) : 5 | BaseDataPage(dp) {} 6 | 7 | MuscleOxygenBaseMainDataPageMsg::MuscleOxygenBaseMainDataPageMsg(uint8_t dataPageNumber) : BaseDataPageMsg() { 8 | setDataBuffer(_buffer); 9 | set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 10 | } 11 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/ANTPLUS_BicyclePowerProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERPROFILE_h 2 | #define ANTPLUS_BICYCLEPOWERPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | #include 13 | 14 | #endif // ANTPLUS_BICYCLEPOWERPROFILE_h 15 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/ANTPLUS_BicycleSpeedProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDPROFILE_h 2 | #define ANTPLUS_BICYCLESPEEDPROFILE_h 3 | 4 | // General Definitions 5 | #include 6 | 7 | // Datapages 8 | #include 9 | 10 | // Profile Classes 11 | #include 12 | #include 13 | 14 | #endif // ANTPLUS_BICYCLESPEEDPROFILE_h 15 | -------------------------------------------------------------------------------- /src/Profiles/Environment/Profiles/ANTPLUS_ProfileEnvironmentMonitor.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEENVIRONMENTMONITOR_h 2 | #define ANTPLUS_PROFILEENVIRONMENTMONITOR_h 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class ProfileEnvironmentMonitor : BaseMasterProfile { 9 | public: 10 | // TODO 11 | explicit ProfileEnvironmentMonitor(uint16_t deviceNumber, uint8_t transmissionType = 0); 12 | }; 13 | 14 | #endif // ANTPLUS_PROFILEENVIRONMENTMONITOR_h 15 | -------------------------------------------------------------------------------- /src/Profiles/Environment/ANTPLUS_EnvironmentDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_ENVIRONMENTPROFILEDEFINES_h 2 | #define ANTPLUS_ENVIRONMENTPROFILEDEFINES_h 3 | 4 | #define ANTPLUS_ENVIRONMENT_DEVICETYPE 25 5 | 6 | #define ANTPLUS_ENVIRONMENT_DATAPAGE_ENVIRONMENT_GENERALINFORMATION_NUMBER 0 7 | 8 | #define ANTPLUS_ENVIRONMENT_DATAPAGE_GENERALINFORMATION_SUPPORTEDPAGES_PAGE0SUPPORT 1 9 | #define ANTPLUS_ENVIRONMENT_DATAPAGE_GENERALINFORMATION_SUPPORTEDPAGES_PAGE1SUPPORT 2 10 | 11 | 12 | #define ANTPLUS_ENVIRONMENT_DATAPAGE_ENVIRONMENT_TEMPERATURE_NUMBER 1 13 | 14 | #endif // ANTPLUS_ENVIRONMENTPROFILEDEFINES_h 15 | -------------------------------------------------------------------------------- /src/Profiles/ANTPLUS_Profiles.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILES_h 2 | #define ANTPLUS_PROFILES_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #endif // ANTPLUS_ANTROUTER_h 14 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateDefault.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define RESERVED_LSB_BYTE 1 5 | #define RESERVED_MSB_BYTE 3 6 | #define RESERVED_VALUE 0xFFFFFF 7 | 8 | HeartRateDefault::HeartRateDefault(AntRxDataResponse& dp) : 9 | HeartRateBaseMainDataPage(dp) {} 10 | 11 | HeartRateDefaultMsg::HeartRateDefaultMsg() : 12 | HeartRateBaseMainDataPageMsg(ANTPLUS_HEARTRATE_DATAPAGE_DEFAULT_NUMBER) { 13 | set24BitValue(RESERVED_VALUE, RESERVED_LSB_BYTE, RESERVED_MSB_BYTE); 14 | } 15 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/DataPages/ANTPLUS_ShiftingBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | ShiftingBaseMainDataPage::ShiftingBaseMainDataPage(AntRxDataResponse& dp) : 6 | BaseDataPage(dp) {} 7 | 8 | ShiftingBaseMainDataPageMsg::ShiftingBaseMainDataPageMsg(uint8_t dataPageNumber) : 9 | BaseDataPageMsg() 10 | { 11 | setDataBuffer(_buffer); 12 | set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 13 | } 14 | -------------------------------------------------------------------------------- /library.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "ANT+", 3 | "keywords": "ant, protocol, radio, rf, ant+, fitness, sports", 4 | "description": "Implements the ANT+ network on top the ANT driver for communication with ANT+ devices. Enables support for integration into various sports sensors/devices.", 5 | "repository": 6 | { 7 | "type": "git", 8 | "url": "https://github.com/cujomalainey/antplus-arduino.git" 9 | }, 10 | "version": "1.2.0", 11 | "frameworks": "*", 12 | "platforms": "*", 13 | "dependencies": 14 | [ 15 | { 16 | "name":"ANT", 17 | "version": ">=2.0.0" 18 | } 19 | ] 20 | } 21 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseSlaveProfile.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | BaseSlaveProfile::BaseSlaveProfile(uint16_t deviceNumber, uint8_t transmissionType) : 5 | BaseProfile(deviceNumber, transmissionType) {} 6 | 7 | uint8_t BaseSlaveProfile::waitForPair() { 8 | // TODO add a timeout in the event packed was dropped? 9 | while (getChannelStatus() == CHANNEL_STATUS_SEARCHING) { 10 | // If a event saying we disconnected happened then we will check it, otherwise wait for data to come in 11 | loop(); 12 | } 13 | return getChannelStatus(); 14 | } 15 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | LevBaseMainDataPage::LevBaseMainDataPage(AntRxDataResponse& dp) : 5 | BaseDataPage(dp) {} 6 | 7 | template 8 | LevBaseMainDataPageMsg::LevBaseMainDataPageMsg(uint8_t dataPageNumber) : 9 | BaseDataPageMsg() { 10 | this->setDataBuffer(_buffer); 11 | this->set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 12 | } 13 | 14 | template class LevBaseMainDataPageMsg; 15 | template class LevBaseMainDataPageMsg; 16 | -------------------------------------------------------------------------------- /src/Profiles/Lev/ANTPLUS_LevDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILELEVDATAPAGES_h 2 | #define ANTPLUS_PROFILELEVDATAPAGES_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #endif // ANTPLUS_PROFILELEVDATAPAGES_h 13 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/ANTPLUS_BicyclePowerDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEBICYCLEPOWERDATAPAGES_h 2 | #define ANTPLUS_PROFILEBICYCLEPOWERDATAPAGES_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #endif // ANTPLUS_PROFILEBICYCLEPOWERDATAPAGES_h 11 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECBASEMAINDATAPAGE_h 2 | #define ANTPLUS_FECBASEMAINDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | class FecBaseMainDataPage : public BaseDataPage { 8 | public: 9 | explicit FecBaseMainDataPage(AntRxDataResponse& dp); 10 | }; 11 | 12 | class FecBaseMainDataPageMsg : public BaseDataPageMsg { 13 | public: 14 | explicit FecBaseMainDataPageMsg(uint8_t dataPageNumber); 15 | protected: 16 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 17 | }; 18 | 19 | #endif // ANTPLUS_FECBASEMAINDATAPAGE_h 20 | -------------------------------------------------------------------------------- /src/ANTPLUS_Defines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_DEFINES_h 2 | #define ANTPLUS_DEFINES_h 3 | 4 | // Misc 5 | #define ANTPLUS_MAX_CHANNELS_POSSIBLE 15 6 | #define ANTPLUS_NETWORKKEY_INDEX 0 7 | #define ANTPLUS_DRIVER_RESET_TIMEOUT 2000 8 | #define ANTPLUS_DRIVER_REQUEST_TIMEOUT 1000 9 | 10 | // Errors 11 | #define ANTPLUS_RESET_RADIO_FAILED 1 12 | #define ANTPLUS_MAX_CHANNEL_CHECK_FAILED 2 13 | #define ANTPLUS_NO_MORE_CHANNELS 255 14 | 15 | // State 16 | #define ANTPLUS_DRIVER_STATE_UNKNOWN 0 17 | #define ANTPLUS_DRIVER_STATE_STARTED 1 18 | 19 | // Reset 20 | #define ANTPLUS_RESET_NO_WAIT_FOR_STARTUP 0 21 | #define ANTPLUS_RESET_WAIT_FOR_STARTUP 1 22 | 23 | #endif // ANTPLUS_DEFINES_h 24 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVBASEMAINDATAPAGE_h 2 | #define ANTPLUS_LEVBASEMAINDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | class LevBaseMainDataPage : public BaseDataPage { 8 | public: 9 | explicit LevBaseMainDataPage(AntRxDataResponse& dp); 10 | }; 11 | 12 | template 13 | class LevBaseMainDataPageMsg : public BaseDataPageMsg { 14 | public: 15 | explicit LevBaseMainDataPageMsg(uint8_t dataPageNumber); 16 | protected: 17 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 18 | }; 19 | 20 | #endif // ANTPLUS_LEVBASEMAINDATAPAGE_h 21 | -------------------------------------------------------------------------------- /src/ANTPLUS_PrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PRIVATEDEFINES_h 2 | #define ANTPLUS_PRIVATEDEFINES_h 3 | 4 | #define ANTPLUS_TRANSMISSIONTYPE_LSN_MASK 0x0F 5 | #define ANTPLUS_TRANSMISSION_SET_LSN(x, flags) ((x & ~ANTPLUS_TRANSMISSIONTYPE_LSN_MASK) | (ANTPLUS_TRANSMISSIONTYPE_LSN_MASK & flags)) 6 | 7 | /* Channel config stuff */ 8 | #define ANTPLUS_CHANNEL_FREQUENCY 57 9 | #define ANTPLUS_DEVICENUMBER_WILDCARD 0 10 | #define ANTPLUS_TRANSMISSIONTYPE_WILDCARD 0 11 | 12 | #define ANTPLUS_DEFAULT_DATAPAGE_BYTE 0 13 | 14 | #define ANTPLUS_DEFAULT_BYTE_MASK 0xFF 15 | 16 | #define ANTPLUS_PAIRING_BIT_MASK 0x80 17 | 18 | #define ANTPLUS_CHANNELEVENT_MESSAGECODE 1 19 | 20 | #endif // ANTPLUS_PRIVATEDEFINES_h 21 | -------------------------------------------------------------------------------- /src/Profiles/Fec/ANTPLUS_FecDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEFECDATAPAGES_h 2 | #define ANTPLUS_PROFILEFECDATAPAGES_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #endif // ANTPLUS_PROFILEFECDATAPAGES_h 14 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/ANTPLUS_BicycleSpeedDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEBICYCLESPEEDDATAPAGES_h 2 | #define ANTPLUS_PROFILEBICYCLESPEEDDATAPAGES_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #endif // ANTPLUS_PROFILEBICYCLESPEEDDATAPAGES_h 12 | -------------------------------------------------------------------------------- /src/Profiles/Fec/ANTPLUS_FecPrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_FECPROFILEPRIVATEDEFINES_h 3 | 4 | #include 5 | 6 | /* Channel Config */ 7 | #define ANTPLUS_FEC_MONITOR_CHANNELTYPE CHANNEL_TYPE_BIDIRECTIONAL_TRANSMIT 8 | #define ANTPLUS_FEC_CHANNELPERIOD 8192 9 | // 30 / 2.5 = 12 10 | #define ANTPLUS_FEC_SEARCHTIMEOUT 12 11 | 12 | // Field common to some base messages 13 | #define FESTATE_BYTE 7 14 | #define FESTATE_MASK 0x70 15 | #define FESTATE_SHIFT 4 16 | #define LAPTOGGLEBIT_BYTE 7 17 | #define LAPTOGGLEBIT_MASK 0x80 18 | #define LAPTOGGLEBIT_SHIFT 7 19 | 20 | #endif // ANTPLUS_FECPROFILEPRIVATEDEFINES_h 21 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/DataPages/ANTPLUS_ShiftingBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_SHIFTINGBASEMAINDATAPAGE_h 2 | #define ANTPLUS_SHIFTINGBASEMAINDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | class ShiftingBaseMainDataPage : public BaseDataPage { 8 | public: 9 | explicit ShiftingBaseMainDataPage(AntRxDataResponse& dp); 10 | }; 11 | 12 | class ShiftingBaseMainDataPageMsg : public BaseDataPageMsg { 13 | public: 14 | explicit ShiftingBaseMainDataPageMsg(uint8_t dataPageNumber); 15 | protected: 16 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 17 | }; 18 | 19 | #endif // ANTPLUS_SHIFTINGBASEMAINDATAPAGE_h 20 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedMotionAndSpeed.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDMOTIONANDSPEED_h 2 | #define ANTPLUS_BICYCLESPEEDMOTIONANDSPEED_h 3 | 4 | #include 5 | 6 | template 7 | class BicycleSpeedBaseMotionAndSpeed : virtual public CoreDataPage { 8 | public: 9 | BicycleSpeedBaseMotionAndSpeed(); 10 | uint8_t getFlags(); 11 | }; 12 | 13 | class BicycleSpeedMotionAndSpeed : public BicycleSpeedBaseMainDataPage, public BicycleSpeedBaseMotionAndSpeed { 14 | public: 15 | explicit BicycleSpeedMotionAndSpeed(AntRxDataResponse& dp); 16 | }; 17 | 18 | #endif // ANTPLUS_BICYCLESPEEDMOTIONANDSPEED_h 19 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/DataPages/ANTPLUS_MuscleOxygenBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MUSCLEOXYGENBASEMAINDATAPAGEMSG_h 2 | #define ANTPLUS_MUSCLEOXYGENBASEMAINDATAPAGEMSG_h 3 | 4 | #include 5 | #include 6 | 7 | class MuscleOxygenBaseMainDataPage : public BaseDataPage { 8 | public: 9 | explicit MuscleOxygenBaseMainDataPage(AntRxDataResponse& dp); 10 | }; 11 | 12 | class MuscleOxygenBaseMainDataPageMsg : public BaseDataPageMsg { 13 | public: 14 | explicit MuscleOxygenBaseMainDataPageMsg(uint8_t dataPageNumber); 15 | protected: 16 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 17 | }; 18 | 19 | #endif // ANTPLUS_MUSCLEOXYGENBASEMAINDATAPAGEMSG_h 20 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/ANTPLUS_HeartRatePrivateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEPROFILEPRIVATEDEFINES_h 2 | #define ANTPLUS_HEARTRATEPROFILEPRIVATEDEFINES_h 3 | 4 | /* Channel Config */ 5 | #define HEARTRATE_CHANNELPERIOD 8070 6 | // 30 / 2.5 = 12 7 | #define HEARTRATE_SEARCHTIMEOUT 12 8 | 9 | /* DataPage Numbers */ 10 | #define HEARTRATE_DEFAULT_NUMBER 0 11 | #define HEARTRATE_CUMULATIVEOPERATINGTIME_NUMBER 1 12 | #define HEARTRATE_MANUFACTURERINFORMATION_NUMBER 2 13 | #define HEARTRATE_PRODUCTINFORMATION_NUMBER 3 14 | #define HEARTRATE_PREVIOUSHEARTBEAT_NUMBER 4 15 | #define HEARTRATE_SWIMINTERVALSUMMARY_NUMBER 5 16 | #define HEARTRATE_CAPABILITIES_NUMBER 6 17 | #define HEARTRATE_BATTERYSTATUS_NUMBER 7 18 | 19 | #endif // ANTPLUS_HEARTRATEPROFILEPRIVATEDEFINES_h 20 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedManufacturerID.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDMANUFACTURERID_h 2 | #define ANTPLUS_BICYCLESPEEDMANUFACTURERID_h 3 | 4 | #include 5 | 6 | template 7 | class BicycleSpeedBaseManufacturerID : virtual public CoreDataPage { 8 | public: 9 | BicycleSpeedBaseManufacturerID(); 10 | uint8_t getManufacturerId(); 11 | uint16_t getSerialNumber(); 12 | }; 13 | 14 | class BicycleSpeedManufacturerID : public BicycleSpeedBaseMainDataPage, public BicycleSpeedBaseManufacturerID { 15 | public: 16 | explicit BicycleSpeedManufacturerID(AntRxDataResponse& dp); 17 | }; 18 | 19 | #endif // ANTPLUS_BICYCLESPEEDMANUFACTURERID_h 20 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_CoreDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "ANT.h" 5 | 6 | template 7 | CoreDataPage::CoreDataPage() : T() {} 8 | 9 | template 10 | uint8_t CoreDataPage::getDataPageNumber() { 11 | // TODO handle shared channels 12 | return this->get8BitValue(ANTPLUS_DEFAULT_DATAPAGE_BYTE); 13 | } 14 | 15 | template 16 | inline int8_t CoreDataPage::getByteStepDirection(uint8_t from, uint8_t to) { 17 | return from < to ? 1 : -1; 18 | } 19 | 20 | template class CoreDataPage; 21 | template class CoreDataPage; 22 | template class CoreDataPage; 23 | template class CoreDataPage; 24 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedProductID.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDPRODUCTIONID_h 2 | #define ANTPLUS_BICYCLESPEEDPRODUCTIONID_h 3 | 4 | #include 5 | 6 | template 7 | class BicycleSpeedBaseProductID : virtual public CoreDataPage { 8 | public: 9 | BicycleSpeedBaseProductID(); 10 | uint8_t getHardwareVersion(); 11 | uint8_t getSoftwareVersion(); 12 | uint8_t getModelNumber(); 13 | }; 14 | 15 | class BicycleSpeedProductID : public BicycleSpeedBaseMainDataPage, public BicycleSpeedBaseProductID { 16 | public: 17 | explicit BicycleSpeedProductID(AntRxDataResponse& dp); 18 | }; 19 | 20 | #endif // ANTPLUS_BICYCLESPEEDPRODUCTIONID_h 21 | -------------------------------------------------------------------------------- /src/Profiles/Environment/DataPages/ANTPLUS_EnvironmentTemperature.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_ENVIRONMENTTEMPERATURE_h 2 | #define ANTPLUS_ENVIRONMENTTEMPERATURE_h 3 | 4 | #include 5 | 6 | template 7 | class EnvironmentBaseTemperature : virtual public CoreDataPage { 8 | public: 9 | EnvironmentBaseTemperature(); 10 | uint8_t getEventCount(); 11 | int16_t get24HourLow(); 12 | int16_t get24HourHigh(); 13 | int16_t getCurrentTemp(); 14 | }; 15 | 16 | class EnvironmentTemperature : public EnvironmentBaseDataPage, public EnvironmentBaseTemperature { 17 | public: 18 | explicit EnvironmentTemperature(AntRxDataResponse& dp); 19 | }; 20 | 21 | #endif // ANTPLUS_ENVIRONMENTTEMPERATURE_h 22 | 23 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedBatteryStatus.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDBATTERYSTATUS_h 2 | #define ANTPLUS_BICYCLESPEEDBATTERYSTATUS_h 3 | 4 | #include 5 | 6 | template 7 | class BicycleSpeedBaseBatteryStatus : virtual public CoreDataPage { 8 | public: 9 | BicycleSpeedBaseBatteryStatus(); 10 | uint8_t getFractionalBatteryVoltage(); 11 | uint8_t getCoarseBatteryVoltage(); 12 | uint8_t getBatteryStatus(); 13 | }; 14 | 15 | class BicycleSpeedBatteryStatus : public BicycleSpeedBaseMainDataPage, public BicycleSpeedBaseBatteryStatus { 16 | public: 17 | explicit BicycleSpeedBatteryStatus(AntRxDataResponse& dp); 18 | }; 19 | 20 | #endif // ANTPLUS_BICYCLESPEEDBATTERYSTATUS_h 21 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecTargetPower.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECTARGETPOWER_h 2 | #define ANTPLUS_FECTARGETPOWER_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseTargetPower : virtual public CoreDataPage { 8 | public: 9 | FecBaseTargetPower(); 10 | uint16_t getTargetPower(); 11 | }; 12 | 13 | class FecTargetPower : public FecBaseMainDataPage, public FecBaseTargetPower { 14 | public: 15 | explicit FecTargetPower(AntRxDataResponse& dp); 16 | }; 17 | 18 | class FecTargetPowerMsg : public FecBaseMainDataPageMsg, public FecBaseTargetPower { 19 | public: 20 | FecTargetPowerMsg(); 21 | void setTargetPower(uint16_t targetPower); 22 | }; 23 | 24 | 25 | #endif // ANTPLUS_FECTARGETPOWER_h 26 | 27 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedCumulativeOperatingTime.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDCUMULITIVEOPERATINGTIME_h 2 | #define ANTPLUS_BICYCLESPEEDCUMULITIVEOPERATINGTIME_h 3 | 4 | #include 5 | 6 | template 7 | class BicycleSpeedBaseCumulativeOperatingTime : virtual public CoreDataPage { 8 | public: 9 | BicycleSpeedBaseCumulativeOperatingTime(); 10 | uint32_t getCumulativeOperatingTime(); // only 24 bits 11 | }; 12 | 13 | class BicycleSpeedCumulativeOperatingTime : public BicycleSpeedBaseMainDataPage, public BicycleSpeedBaseCumulativeOperatingTime { 14 | public: 15 | explicit BicycleSpeedCumulativeOperatingTime(AntRxDataResponse& dp); 16 | }; 17 | 18 | #endif // ANTPLUS_BICYCLESPEEDCUMULITIVEOPERATINGTIME_h 19 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedMotionAndSpeed.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define FLAGS_BYTE 1 5 | 6 | template 7 | BicycleSpeedBaseMotionAndSpeed::BicycleSpeedBaseMotionAndSpeed() : 8 | CoreDataPage() {} 9 | 10 | template 11 | uint8_t BicycleSpeedBaseMotionAndSpeed::getFlags() { 12 | return this->get8BitValue(FLAGS_BYTE); 13 | } 14 | 15 | template class BicycleSpeedBaseMotionAndSpeed; 16 | template class BicycleSpeedBaseMotionAndSpeed; 17 | 18 | BicycleSpeedMotionAndSpeed::BicycleSpeedMotionAndSpeed(AntRxDataResponse& dp) : 19 | BicycleSpeedBaseMainDataPage(dp), 20 | BicycleSpeedBaseMotionAndSpeed() {} 21 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/ANTPLUS_HeartRateDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEHEARTRATEDATAPAGES_h 2 | #define ANTPLUS_PROFILEHEARTRATEDATAPAGES_h 3 | 4 | /* RX */ 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #endif // ANTPLUS_PROFILEHEARTRATEDATAPAGES_h 15 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecBasicResistance.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECBASICRESISTANCE_h 2 | #define ANTPLUS_FECBASICRESISTANCE_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseBasicResistance : virtual public CoreDataPage { 8 | public: 9 | FecBaseBasicResistance(); 10 | uint8_t getTotalResistance(); 11 | }; 12 | 13 | class FecBasicResistance : public FecBaseMainDataPage, public FecBaseBasicResistance { 14 | public: 15 | explicit FecBasicResistance(AntRxDataResponse& dp); 16 | }; 17 | 18 | class FecBasicResistanceMsg : public FecBaseMainDataPageMsg, public FecBaseBasicResistance { 19 | public: 20 | FecBasicResistanceMsg(); 21 | void setTotalResistance(uint8_t totalResistance); 22 | }; 23 | 24 | 25 | #endif // ANTPLUS_FECBASICRESISTANCE_h 26 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERBASEMAINDATAPAGE_h 2 | #define ANTPLUS_BICYCLEPOWERBASEMAINDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | class BicyclePowerBaseMainDataPage : public BaseDataPage { 8 | public: 9 | explicit BicyclePowerBaseMainDataPage(AntRxDataResponse& dp); 10 | uint8_t getDataPageNumber() override; 11 | uint8_t getUpdateEventCount(); 12 | }; 13 | 14 | class BicyclePowerBaseMainDataPageMsg : public BaseDataPageMsg { 15 | public: 16 | explicit BicyclePowerBaseMainDataPageMsg(uint8_t dataPageNumber); 17 | void setUpdateEventCount(uint8_t eventCount); 18 | protected: 19 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 20 | }; 21 | 22 | #endif // ANTPLUS_BICYCLEPOWERPOWERONLYDATAPAGE_h 23 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ModeSettings.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MODESETTINGS_h 2 | #define ANTPLUS_MODESETTINGS_h 3 | 4 | #include 5 | #include 6 | 7 | // Common page 76 8 | 9 | template 10 | class BaseModeSettings : virtual public CoreDataPage { 11 | public: 12 | BaseModeSettings(); 13 | uint8_t getSportMode(); 14 | }; 15 | 16 | class ModeSettings : public BaseDataPage, public BaseModeSettings { 17 | public: 18 | explicit ModeSettings(AntRxDataResponse& dp); 19 | }; 20 | 21 | class ModeSettingsMsg : public BaseDataPageMsg, public BaseModeSettings { 22 | ModeSettingsMsg(); 23 | void setSportMode(uint8_t sportsMode); 24 | private: 25 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 26 | }; 27 | 28 | #endif // ANTPLUS_MODESETTINGS_h 29 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BASEDATAPAGE_h 2 | #define ANTPLUS_BASEDATAPAGE_h 3 | 4 | #include 5 | 6 | #include "ANT.h" 7 | 8 | template 9 | class BaseDataPage : virtual public CoreDataPage { 10 | public: 11 | explicit BaseDataPage(AntRxDataResponse& msg); 12 | #ifndef UNIT_TEST 13 | protected: 14 | #endif // UNIT_TEST 15 | uint8_t get8BitValue(uint8_t byte, uint8_t mask = 0xFF, uint8_t shift = 0) override; 16 | uint16_t get16BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint16_t mask = 0xFFFF, uint8_t shift = 0) override; 17 | uint32_t get24BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFF, uint8_t shift = 0) override; 18 | uint32_t get32BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFFFF, uint8_t shift = 0) override; 19 | }; 20 | 21 | #endif // ANTPLUS_BASEDATAPAGE_h 22 | -------------------------------------------------------------------------------- /src/Profiles/Environment/DataPages/ANTPLUS_EnvironmentGeneralInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_ENVIRONMENTGENERALINFORMATION_h 2 | #define ANTPLUS_ENVIRONMENTGENERALINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class EnvironmentBaseGeneralInformation : virtual public CoreDataPage { 8 | public: 9 | EnvironmentBaseGeneralInformation(); 10 | uint8_t getTransmissionInfoLocalTime(); 11 | uint8_t getTransmissionInfoUtcTime(); 12 | uint8_t getTransmissionInfoDefaultTransmissionRate(); 13 | uint32_t getSupportedPages(); 14 | }; 15 | 16 | class EnvironmentGeneralInformation : public EnvironmentBaseDataPage, public EnvironmentBaseGeneralInformation { 17 | public: 18 | explicit EnvironmentGeneralInformation(AntRxDataResponse& dp); 19 | }; 20 | 21 | #endif // ANTPLUS_ENVIRONMENTGENERALINFORMATION_h 22 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecTrackResistance.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECTRACKRESISTANCE_h 2 | #define ANTPLUS_FECTRACKRESISTANCE_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseTrackResistance : virtual public CoreDataPage { 8 | public: 9 | FecBaseTrackResistance(); 10 | uint16_t getGrade(); 11 | uint8_t getCoefficientOfRollingResistance(); 12 | }; 13 | 14 | class FecTrackResistance : public FecBaseMainDataPage, public FecBaseTrackResistance { 15 | public: 16 | explicit FecTrackResistance(AntRxDataResponse& dp); 17 | }; 18 | 19 | class FecTrackResistanceMsg : public FecBaseMainDataPageMsg, public FecBaseTrackResistance { 20 | public: 21 | FecTrackResistanceMsg(); 22 | void setTargetGrade(uint16_t targetGrade); 23 | void setCoefficientOfRollingResistance(uint8_t coefficient); 24 | }; 25 | 26 | 27 | #endif // ANTPLUS_FECTRACKRESISTANCE_h 28 | 29 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateCapabilities.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATECAPABILITIES_h 2 | #define ANTPLUS_HEARTRATECAPABILITIES_h 3 | 4 | #include 5 | 6 | template 7 | class HeartRateBaseCapabilities : virtual public CoreDataPage { 8 | public: 9 | HeartRateBaseCapabilities(); 10 | uint8_t getFeaturesSupported(); 11 | uint8_t getFeaturesEnabled(); 12 | }; 13 | 14 | class HeartRateCapabilities : public HeartRateBaseMainDataPage, public HeartRateBaseCapabilities { 15 | public: 16 | explicit HeartRateCapabilities(AntRxDataResponse& dp); 17 | }; 18 | 19 | class HeartRateCapabilitiesMsg : public HeartRateBaseMainDataPageMsg, HeartRateBaseCapabilities { 20 | public: 21 | HeartRateCapabilitiesMsg(); 22 | void setFeaturesSupported(uint8_t supported); 23 | void setFeaturesEnabled(uint8_t enabled); 24 | }; 25 | 26 | #endif // ANTPLUS_HEARTRATECAPABILITIES_h 27 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevSpeedDistanceInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVSPEEDDISTANCEINFORMATION_h 2 | #define ANTPLUS_LEVSPEEDDISTANCEINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class LevInternalSpeedDistanceInformation : virtual public CoreDataPage { 8 | public: 9 | LevInternalSpeedDistanceInformation(); 10 | uint16_t getRemainingRange(); // in km 11 | }; 12 | 13 | class LevSpeedDistanceInformation : public LevBaseSpeedDistanceInformation, public LevInternalSpeedDistanceInformation { 14 | public: 15 | explicit LevSpeedDistanceInformation(AntRxDataResponse& dp); 16 | }; 17 | 18 | class LevSpeedDistanceInformationMsg : public LevBaseSpeedDistanceInformationMsg, public LevInternalSpeedDistanceInformation { 19 | public: 20 | LevSpeedDistanceInformationMsg(); 21 | void setRemainingRange(uint16_t remainingRange); // in km 22 | }; 23 | 24 | #endif // ANTPLUS_LEVSPEEDDISTANCEINFORMATION_h 25 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevAltSpeedDistanceInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVALTSPEEDDISTANCEINFORMATION_h 2 | #define ANTPLUS_LEVALTSPEEDDISTANCEINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class LevBaseAltSpeedDistanceInformation : virtual public CoreDataPage { 8 | public: 9 | LevBaseAltSpeedDistanceInformation(); 10 | uint16_t getFuelConsumption(); // in Wh/km 11 | }; 12 | 13 | class LevAltSpeedDistanceInformation : public LevBaseSpeedDistanceInformation, public LevBaseAltSpeedDistanceInformation { 14 | public: 15 | explicit LevAltSpeedDistanceInformation(AntRxDataResponse& dp); 16 | }; 17 | 18 | class LevAltSpeedDistanceInformationMsg : public LevBaseSpeedDistanceInformationMsg, public LevBaseAltSpeedDistanceInformation { 19 | public: 20 | LevAltSpeedDistanceInformationMsg(); 21 | void setFuelConsumption(uint16_t consumption); // in Wh/km 22 | }; 23 | 24 | #endif // ANTPLUS_LEVALTSPEEDDISTANCEINFORMATION_h 25 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateCumulativeOperatingTime.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATECUMULITIVEOPERATINGTIME_h 2 | #define ANTPLUS_HEARTRATECUMULITIVEOPERATINGTIME_h 3 | 4 | #include 5 | 6 | template 7 | class HeartRateBaseCumulativeOperatingTime : virtual public CoreDataPage { 8 | public: 9 | HeartRateBaseCumulativeOperatingTime(); 10 | uint32_t getCumulativeOperatingTime(); // only 24 bits 11 | }; 12 | 13 | class HeartRateCumulativeOperatingTime : public HeartRateBaseMainDataPage, public HeartRateBaseCumulativeOperatingTime { 14 | public: 15 | explicit HeartRateCumulativeOperatingTime(AntRxDataResponse& dp); 16 | }; 17 | 18 | class HeartRateCumulativeOperatingTimeMsg : public HeartRateBaseMainDataPageMsg, public HeartRateBaseCumulativeOperatingTime { 19 | public: 20 | HeartRateCumulativeOperatingTimeMsg(); 21 | void setCumulativeOperatingTime(uint32_t time); 22 | }; 23 | 24 | #endif // ANTPLUS_HEARTRATECUMULITIVEOPERATINGTIME_h 25 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevCapabilities.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVCAPABILITIES_h 2 | #define ANTPLUS_LEVCAPABILITIES_h 3 | 4 | #include 5 | 6 | template 7 | class LevBaseCapabilities : virtual public CoreDataPage { 8 | public: 9 | LevBaseCapabilities(); 10 | uint8_t getNumberOfAssistModesSupported(); 11 | uint8_t getNumberOfRegenerativeModesSupported(); 12 | uint16_t getWheelCircumference(); 13 | }; 14 | 15 | class LevCapabilities : public LevBaseMainDataPage, public LevBaseCapabilities { 16 | public: 17 | explicit LevCapabilities(AntRxDataResponse& dp); 18 | }; 19 | 20 | class LevCapabilitiesMsg : public LevBaseMainDataPageMsg, public LevBaseCapabilities { 21 | public: 22 | LevCapabilitiesMsg(); 23 | void setNumberOfAssistModesSupported(uint8_t modes); 24 | void setNumberOfRegenerativeModesSupported(uint8_t modes); 25 | void setWheelCircumference(uint16_t circumference); 26 | }; 27 | 28 | #endif // ANTPLUS_LEVCAPABILITIES_h 29 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRatePreviousHeartBeat.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEPREVIOUSHEARTBEAT_h 2 | #define ANTPLUS_HEARTRATEPREVIOUSHEARTBEAT_h 3 | 4 | #include 5 | 6 | template 7 | class HeartRateBasePreviousHeartBeat : virtual public CoreDataPage { 8 | public: 9 | HeartRateBasePreviousHeartBeat(); 10 | uint8_t getManufacturerSpecific(); 11 | uint16_t getPreviousHeartBeatEventTime(); 12 | }; 13 | 14 | class HeartRatePreviousHeartBeat : public HeartRateBaseMainDataPage, public HeartRateBasePreviousHeartBeat { 15 | public: 16 | explicit HeartRatePreviousHeartBeat(AntRxDataResponse& dp); 17 | }; 18 | 19 | class HeartRatePreviousHeartBeatMsg : public HeartRateBaseMainDataPageMsg, public HeartRateBasePreviousHeartBeat { 20 | public: 21 | HeartRatePreviousHeartBeatMsg(); 22 | void setManufacturerSpecific(uint8_t specificByte); 23 | void setPreviousHeartBeatEventTime(uint16_t eventTime); 24 | }; 25 | 26 | #endif // ANTPLUS_HEARTRATEPREVIOUSHEARTBEAT_h 27 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedCumulativeOperatingTime.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define CUMULATIVEOPERATINGTIME_TIME_LSB_BYTE 1 5 | #define CUMULATIVEOPERATINGTIME_TIME_MSB_BYTE 3 6 | 7 | template 8 | BicycleSpeedBaseCumulativeOperatingTime::BicycleSpeedBaseCumulativeOperatingTime() : 9 | CoreDataPage() {} 10 | 11 | template 12 | uint32_t BicycleSpeedBaseCumulativeOperatingTime::getCumulativeOperatingTime() { 13 | return this->get24BitValue(CUMULATIVEOPERATINGTIME_TIME_LSB_BYTE, 14 | CUMULATIVEOPERATINGTIME_TIME_MSB_BYTE); 15 | } 16 | 17 | template class BicycleSpeedBaseCumulativeOperatingTime; 18 | template class BicycleSpeedBaseCumulativeOperatingTime; 19 | 20 | BicycleSpeedCumulativeOperatingTime::BicycleSpeedCumulativeOperatingTime(AntRxDataResponse& dp) : 21 | BicycleSpeedBaseMainDataPage(dp), BicycleSpeedBaseCumulativeOperatingTime() {} 22 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_CommonDataPages.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_COMMONHEADERS_h 2 | #define ANTPLUS_COMMONHEADERS_h 3 | 4 | // RX 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | #endif // ANTPLUS_COMMONHEADERS_h 23 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/DataPages/ANTPLUS_MuscleOxygenCommands.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MUSCLEOXYGENCOMMANDS_h 2 | #define ANTPLUS_MUSCLEOXYGENCOMMANDS_h 3 | 4 | #include 5 | 6 | template 7 | class MuscleOxygenBaseCommands : public virtual CoreDataPage { 8 | public: 9 | MuscleOxygenBaseCommands(); 10 | uint8_t getCommandId(); 11 | uint8_t getLocalTimeOffset(); 12 | uint32_t getCurrentTimestamp(); 13 | }; 14 | 15 | class MuscleOxygenCommands : 16 | public MuscleOxygenBaseMainDataPage, 17 | public MuscleOxygenBaseCommands { 18 | public: 19 | explicit MuscleOxygenCommands(AntRxDataResponse& dp); 20 | }; 21 | 22 | class MuscleOxygenCommandsMsg : 23 | public MuscleOxygenBaseMainDataPageMsg, 24 | public MuscleOxygenBaseCommands { 25 | public: 26 | MuscleOxygenCommandsMsg(); 27 | void setCommandId(uint8_t id); 28 | void setLocalTimeOffset(uint8_t offset); 29 | void setCurrentTimestamp(uint32_t timestamp); 30 | }; 31 | 32 | #endif // ANTPLUS_MUSCLEOXYGENMUSCLEOXYGENDATA_h 33 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateManufacturerInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEMANUFACTURERINFORMATION_h 2 | #define ANTPLUS_HEARTRATEMANUFACTURERINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class HeartRateBaseManufacturerInformation : virtual public CoreDataPage { 8 | public: 9 | HeartRateBaseManufacturerInformation(); 10 | uint8_t getManufacturerIdLsb(); 11 | uint16_t getSerialNumber(); 12 | }; 13 | 14 | class HeartRateManufacturerInformation : public HeartRateBaseMainDataPage, public HeartRateBaseManufacturerInformation { 15 | public: 16 | explicit HeartRateManufacturerInformation(AntRxDataResponse& dp); 17 | }; 18 | 19 | class HeartRateManufacturerInformationMsg : public HeartRateBaseMainDataPageMsg, public HeartRateBaseManufacturerInformation { 20 | public: 21 | HeartRateManufacturerInformationMsg(); 22 | void setManufacturerIdLsb(uint8_t id); 23 | void setSerialNumber(uint16_t serialNumber); 24 | }; 25 | 26 | #endif // ANTPLUS_HEARTRATEMANUFACTURERINFORMATION_h 27 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedManufacturerID.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define MANUFACTUREREID_BYTE 1 5 | #define SERIALNUMBER_LSB_BYTE 2 6 | #define SERIALNUMBER_MSB_BYTE 3 7 | 8 | template 9 | BicycleSpeedBaseManufacturerID::BicycleSpeedBaseManufacturerID() : 10 | CoreDataPage() {} 11 | 12 | template 13 | uint8_t BicycleSpeedBaseManufacturerID::getManufacturerId() { 14 | return this->get8BitValue(MANUFACTUREREID_BYTE); 15 | } 16 | 17 | template 18 | uint16_t BicycleSpeedBaseManufacturerID::getSerialNumber() { 19 | return this->get16BitValue(SERIALNUMBER_LSB_BYTE, SERIALNUMBER_MSB_BYTE); 20 | } 21 | 22 | template class BicycleSpeedBaseManufacturerID; 23 | template class BicycleSpeedBaseManufacturerID; 24 | 25 | BicycleSpeedManufacturerID::BicycleSpeedManufacturerID(AntRxDataResponse& dp) : 26 | BicycleSpeedBaseMainDataPage(dp), 27 | BicycleSpeedBaseManufacturerID() {} 28 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevBaseSpeedDistanceInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVBASESPEEDDISTANCEINFORMATION_h 2 | #define ANTPLUS_LEVBASESPEEDDISTANCEINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class LevCoreSpeedDistanceInformation : virtual public CoreDataPage { 8 | public: 9 | LevCoreSpeedDistanceInformation(); 10 | uint32_t getOdometer(); // in km 11 | uint16_t getLevSpeed(); // in 1/10 km/h 12 | }; 13 | 14 | class LevBaseSpeedDistanceInformation : public LevBaseMainDataPage, public LevCoreSpeedDistanceInformation { 15 | public: 16 | explicit LevBaseSpeedDistanceInformation(AntRxDataResponse& dp); 17 | }; 18 | 19 | class LevBaseSpeedDistanceInformationMsg : public LevBaseMainDataPageMsg, public LevCoreSpeedDistanceInformation { 20 | public: 21 | LevBaseSpeedDistanceInformationMsg(uint8_t dataPageNumber); 22 | void setOdometer(uint32_t odometer); // in km 23 | void setLevSpeed(uint16_t speed); // in 1/10 km/h 24 | }; 25 | 26 | #endif // ANTPLUS_LEVBASESPEEDDISTANCEINFORMATION_h 27 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevSpeedSystemInformation2.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVSPEEDSYSTEMINFORMATION2_h 2 | #define ANTPLUS_LEVSPEEDSYSTEMINFORMATION2_h 3 | 4 | #include 5 | 6 | template 7 | class LevBaseSpeedSystemInformation2 : virtual public CoreDataPage { 8 | public: 9 | LevBaseSpeedSystemInformation2(); 10 | uint8_t getBatterySOC(); 11 | uint8_t getBatteryEmptyWarning(); 12 | uint8_t getPercentAssist(); 13 | }; 14 | 15 | class LevSpeedSystemInformation2 : public LevBaseSpeedSystemInformation, public LevBaseSpeedSystemInformation2 { 16 | public: 17 | explicit LevSpeedSystemInformation2(AntRxDataResponse& dp); 18 | }; 19 | 20 | class LevSpeedSystemInformation2Msg : public LevBaseSpeedSystemInformationMsg, public LevBaseSpeedSystemInformation2 { 21 | public: 22 | LevSpeedSystemInformation2Msg(); 23 | void setBatterySOC(uint8_t soc); 24 | void setBatteryEmptyWarning(uint8_t warning); 25 | void setPercentAssist(uint8_t percent); 26 | }; 27 | 28 | #endif // ANTPLUS_LEVSPEEDSYSTEMINFORMATION2_h 29 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_CoreDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_COREDATAPAGE_h 2 | #define ANTPLUS_COREDATAPAGE_h 3 | 4 | #include 5 | 6 | template 7 | class CoreDataPage : public T { 8 | public: 9 | CoreDataPage(); 10 | virtual uint8_t getDataPageNumber(); 11 | #ifndef UNIT_TEST 12 | protected: 13 | #endif // UNIT_TEST 14 | /** 15 | * These values are assumed to contiguous in their bit fields, they will not work 16 | * for fields that are fragemented. Therefore inner bytes are assumed to have a mask 17 | * of 0xFF. 18 | */ 19 | int8_t getByteStepDirection(uint8_t from, uint8_t to); 20 | virtual uint8_t get8BitValue(uint8_t byte, uint8_t mask = 0xFF, uint8_t shift = 0) = 0; 21 | virtual uint16_t get16BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint16_t mask = 0xFFFF, uint8_t shift = 0) = 0; 22 | virtual uint32_t get24BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFF, uint8_t shift = 0) = 0; 23 | virtual uint32_t get32BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFFFF, uint8_t shift = 0) = 0; 24 | }; 25 | 26 | #endif // ANTPLUS_COREDATAPAGE_h 27 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecFeCapabilities.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECFECAPABILITIES_h 2 | #define ANTPLUS_FECFECAPABILITIES_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseFeCapabilities : virtual public CoreDataPage { 8 | public: 9 | FecBaseFeCapabilities(); 10 | uint16_t getMaximumResistance(); 11 | uint8_t getBasicResistanceModeSupport(); 12 | uint8_t getTargetPowerModeSupport(); 13 | uint8_t getSimulationModeSupport(); 14 | }; 15 | 16 | class FecFeCapabilities : public FecBaseMainDataPage, public FecBaseFeCapabilities { 17 | public: 18 | explicit FecFeCapabilities(AntRxDataResponse& dp); 19 | }; 20 | 21 | class FecFeCapabilitiesMsg : public FecBaseMainDataPageMsg, public FecBaseFeCapabilities { 22 | public: 23 | FecFeCapabilitiesMsg(); 24 | void setMaximumResistance(uint16_t UserWeight); 25 | void setBasicResistanceModeSupport(uint8_t support); 26 | void setTargetPowerModeSupport(uint8_t support); 27 | void setSimulationModeSupport(uint8_t support); 28 | }; 29 | 30 | #endif // ANTPLUS_FECFECAPABILITIES_h 31 | 32 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateProductInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEPRODUCTIONINFORMATION_h 2 | #define ANTPLUS_HEARTRATEPRODUCTIONINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class HeartRateBaseProductInformation : virtual public CoreDataPage { 8 | public: 9 | HeartRateBaseProductInformation(); 10 | uint8_t getHardwareVersion(); 11 | uint8_t getSoftwareVersion(); 12 | uint8_t getModelNumber(); 13 | }; 14 | 15 | class HeartRateProductInformation : public HeartRateBaseMainDataPage, public HeartRateBaseProductInformation { 16 | public: 17 | explicit HeartRateProductInformation(AntRxDataResponse& dp); 18 | }; 19 | 20 | class HeartRateProductInformationMsg : public HeartRateBaseMainDataPageMsg, public HeartRateBaseProductInformation { 21 | public: 22 | HeartRateProductInformationMsg(); 23 | void setHardwareVersion(uint8_t hwVersion); 24 | void setSoftwareVersion(uint8_t swVersion); 25 | void setModelNumber(uint8_t modelNumber); 26 | }; 27 | 28 | #endif // ANTPLUS_HEARTRATEPRODUCTIONINFORMATION_h 29 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ProductInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PRODUCTINFORMATION_h 2 | #define ANTPLUS_PRODUCTINFORMATION_h 3 | 4 | #include 5 | #include 6 | 7 | // Common page 81 8 | 9 | template 10 | class BaseProductInformation : virtual public CoreDataPage { 11 | public: 12 | BaseProductInformation(); 13 | uint8_t getSWRevisionSupplemental(); 14 | uint8_t getSWRevisionMain(); 15 | uint32_t getSerialNumber(); 16 | }; 17 | 18 | class ProductInformation : public BaseDataPage, public BaseProductInformation { 19 | public: 20 | explicit ProductInformation(AntRxDataResponse& dp); 21 | }; 22 | 23 | class ProductInformationMsg : public BaseDataPageMsg, public BaseProductInformation { 24 | public: 25 | ProductInformationMsg(); 26 | void setSWRevisionSupplemental(uint8_t revision); 27 | void setSWRevisionMain(uint8_t revision); 28 | void setSerialNumber(uint32_t serialNumber); 29 | private: 30 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 31 | }; 32 | 33 | #endif // ANTPLUS_PRODUCTINFORMATION_h 34 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | // TODO make second base class for callibration messages 6 | #define UPDATEEVENTCOUNT_BYTE 1 7 | 8 | BicyclePowerBaseMainDataPage::BicyclePowerBaseMainDataPage(AntRxDataResponse& dp) : 9 | BaseDataPage(dp) {} 10 | 11 | uint8_t BicyclePowerBaseMainDataPage::getDataPageNumber() { 12 | return this->get8BitValue(ANTPLUS_DEFAULT_DATAPAGE_BYTE); 13 | } 14 | 15 | uint8_t BicyclePowerBaseMainDataPage::getUpdateEventCount() { 16 | return this->get8BitValue(UPDATEEVENTCOUNT_BYTE); 17 | } 18 | 19 | BicyclePowerBaseMainDataPageMsg::BicyclePowerBaseMainDataPageMsg(uint8_t dataPageNumber) : 20 | BaseDataPageMsg() { 21 | setDataBuffer(_buffer); 22 | set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 23 | }; 24 | 25 | void BicyclePowerBaseMainDataPageMsg::setUpdateEventCount(uint8_t eventCount) { 26 | set8BitValue(eventCount, UPDATEEVENTCOUNT_BYTE); 27 | } 28 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevBatteryInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVBATTERYINFORMATION_h 2 | #define ANTPLUS_LEVBATTERYINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class LevBaseBatteryInformation : virtual public CoreDataPage { 8 | public: 9 | LevBaseBatteryInformation(); 10 | uint16_t getChargingCycleCount(); 11 | uint16_t getFuelConsumption(); 12 | uint8_t getBatteryVoltage(); 13 | uint16_t getDistanceOnCurrentCharge(); 14 | }; 15 | 16 | class LevBatteryInformation : public LevBaseMainDataPage, public LevBaseBatteryInformation { 17 | public: 18 | explicit LevBatteryInformation(AntRxDataResponse& dp); 19 | }; 20 | 21 | class LevBatteryInformationMsg : public LevBaseMainDataPageMsg, public LevBaseBatteryInformation { 22 | public: 23 | LevBatteryInformationMsg(); 24 | void setChargingCycleCount(uint16_t cycleCount); 25 | void setFuelConsumption(uint16_t consumption); 26 | void setBatteryVoltage(uint8_t voltage); 27 | void setDistanceOnCurrentCharge(uint16_t distance); 28 | }; 29 | #endif // ANTPLUS_LEVBATTERYINFORMATION_h 30 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedProductID.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define HARDWAREVERSION_BYTE 1 5 | #define SOFTWAREVERSION_BYTE 2 6 | #define MODELNUMBER_BYTE 3 7 | 8 | template 9 | BicycleSpeedBaseProductID::BicycleSpeedBaseProductID() : CoreDataPage() {} 10 | 11 | template 12 | uint8_t BicycleSpeedBaseProductID::getHardwareVersion() { 13 | return this->get8BitValue(HARDWAREVERSION_BYTE); 14 | } 15 | 16 | template 17 | uint8_t BicycleSpeedBaseProductID::getSoftwareVersion() { 18 | return this->get8BitValue(SOFTWAREVERSION_BYTE); 19 | } 20 | 21 | template 22 | uint8_t BicycleSpeedBaseProductID::getModelNumber() { 23 | return this->get8BitValue(MODELNUMBER_BYTE); 24 | } 25 | 26 | template class BicycleSpeedBaseProductID; 27 | template class BicycleSpeedBaseProductID; 28 | 29 | BicycleSpeedProductID::BicycleSpeedProductID(AntRxDataResponse& dp) : 30 | BicycleSpeedBaseMainDataPage(dp), 31 | BicycleSpeedBaseProductID() {} 32 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateBatteryStatus.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEBATTERYSTATUS_h 2 | #define ANTPLUS_HEARTRATEBATTERYSTATUS_h 3 | 4 | #include 5 | 6 | template 7 | class HeartRateBaseBatteryStatus : virtual public CoreDataPage { 8 | public: 9 | HeartRateBaseBatteryStatus(); 10 | uint8_t getBatteryLevel(); 11 | uint8_t getFractionalBatteryVoltage(); 12 | uint8_t getCoarseBatteryVoltage(); 13 | uint8_t getBatteryStatus(); 14 | }; 15 | 16 | class HeartRateBatteryStatus : public HeartRateBaseMainDataPage, public HeartRateBaseBatteryStatus { 17 | public: 18 | explicit HeartRateBatteryStatus(AntRxDataResponse& dp); 19 | }; 20 | 21 | class HeartRateBatteryStatusMsg : public HeartRateBaseMainDataPageMsg, public HeartRateBaseBatteryStatus { 22 | public: 23 | HeartRateBatteryStatusMsg(); 24 | void setBatteryLevel(uint8_t level); 25 | void setFractionalBatteryVoltage(uint8_t voltage); 26 | void setCoarseBatteryVolage(uint8_t voltage); 27 | void setBatteryStatus(uint8_t status); 28 | }; 29 | 30 | #endif // ANTPLUS_HEARTRATEBATTERYSTATUS_h 31 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ManufacturersInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MANUFACTURERSINFORMATION_h 2 | #define ANTPLUS_MANUFACTURERSINFORMATION_h 3 | 4 | #include 5 | #include 6 | 7 | // Common page 80 8 | 9 | template 10 | class BaseManufacturersInformation : virtual public CoreDataPage { 11 | public: 12 | BaseManufacturersInformation(); 13 | uint8_t getHWRevision(); 14 | uint16_t getManufacturerID(); 15 | uint16_t getModelNumber(); 16 | }; 17 | 18 | class ManufacturersInformation : public BaseDataPage, public BaseManufacturersInformation { 19 | public: 20 | explicit ManufacturersInformation(AntRxDataResponse& dp); 21 | }; 22 | 23 | class ManufacturersInformationMsg : public BaseDataPageMsg, BaseManufacturersInformation { 24 | public: 25 | ManufacturersInformationMsg(); 26 | void setHWRevision(uint8_t revision); 27 | void setManufacturerId(uint16_t id); 28 | void setModelNumber(uint16_t modelNumber); 29 | private: 30 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 31 | }; 32 | 33 | #endif // ANTPLUS_MANUFACTURERSINFORMATION_h 34 | -------------------------------------------------------------------------------- /platformio.ini: -------------------------------------------------------------------------------- 1 | # 2 | # Project Configuration File 3 | # 4 | # A detailed documentation with the EXAMPLES is located here: 5 | # http://docs.platformio.org/en/latest/projectconf.html 6 | # 7 | 8 | # A sign `#` at the beginning of the line indicates a comment 9 | # Comment lines are ignored. 10 | 11 | # Simple and base environment 12 | # [env:mybaseenv] 13 | # platform = %INSTALLED_PLATFORM_NAME_HERE% 14 | # framework = 15 | # board = 16 | # 17 | # Automatic targets - enable auto-uploading 18 | # targets = upload 19 | 20 | [env:teensy31] 21 | platform = teensy 22 | framework = arduino 23 | board = teensy31 24 | lib_deps = ANT 25 | 26 | [env:native] 27 | platform = native 28 | build_flags = -Wno-c++11-extensions -std=c++11 29 | test_build_project_src = true 30 | lib_deps = ANT 31 | lib_compat_mode = off 32 | 33 | [env:huzzah32] 34 | platform = espressif32 35 | framework = arduino 36 | board = featheresp32 37 | lib_deps = ANT 38 | 39 | [env:nrf52_express] 40 | board = adafruit_feather_nrf52840_s340 41 | framework = arduino 42 | platform = nordicnrf52 43 | platform_packages = framework-arduinoadafruitnrf52 @ https://github.com/cujomalainey/Adafruit_nRF52_Arduino 44 | lib_deps = https://github.com/cujomalainey/ant-arduino.git#develop 45 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerCrankTorqueFrequency.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERCRANKTORQUEFREQUENCY_h 2 | #define ANTPLUS_BICYCLEPOWERCRANKTORQUEFREQUENCY_h 3 | 4 | #include 5 | 6 | template 7 | class BicyclePowerBaseCrankTorqueFrequency : virtual public CoreDataPage { 8 | public: 9 | BicyclePowerBaseCrankTorqueFrequency(); 10 | uint16_t getSlope(); 11 | uint16_t getTimeStamp(); 12 | uint16_t getTorqueTicksStamp(); 13 | }; 14 | 15 | class BicyclePowerCrankTorqueFrequency : 16 | public BicyclePowerBaseMainDataPage, 17 | public BicyclePowerBaseCrankTorqueFrequency { 18 | public: 19 | explicit BicyclePowerCrankTorqueFrequency(AntRxDataResponse& dp); 20 | }; 21 | 22 | class BicyclePowerCrankTorqueFrequencyMsg : 23 | public BicyclePowerBaseMainDataPageMsg, 24 | public BicyclePowerBaseCrankTorqueFrequency { 25 | public: 26 | BicyclePowerCrankTorqueFrequencyMsg(); 27 | void setSlope(uint16_t slope); 28 | void setTimeStamp(uint16_t timestamp); 29 | void setTorqueTicksStamp(uint16_t tickstamp); 30 | }; 31 | 32 | #endif // ANTPLUS_BICYCLEPOWERCRANKTORQUEFREQUENCY_h 33 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecUserConfiguration.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECUSERCONFIGURATION_h 2 | #define ANTPLUS_FECUSERCONFIGURATION_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseUserConfiguration : virtual public CoreDataPage { 8 | public: 9 | FecBaseUserConfiguration(); 10 | uint16_t getUserWeight(); 11 | uint8_t getBicycleWheelDiameterOffset(); 12 | uint16_t getBicycleWeight(); 13 | uint8_t getBicycleWheelDiameter(); 14 | uint8_t getGearRatio(); 15 | }; 16 | 17 | class FecUserConfiguration : public FecBaseMainDataPage, public FecBaseUserConfiguration { 18 | public: 19 | explicit FecUserConfiguration(AntRxDataResponse& dp); 20 | }; 21 | 22 | class FecUserConfigurationMsg : public FecBaseMainDataPageMsg, public FecBaseUserConfiguration { 23 | public: 24 | FecUserConfigurationMsg(); 25 | void setUserWeight(uint16_t userWeight); 26 | void setBicycleWheelDiameterOffset(uint8_t offset); 27 | void setBicycleWeight(uint16_t bicycleWeight); 28 | void setBicycleWheelDiameter(uint8_t diameter); 29 | void setGearRatio(uint8_t gearRatio); 30 | }; 31 | 32 | #endif // ANTPLUS_FECUSERCONFIGURATION_h 33 | 34 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/ANTPLUS_BicycleSpeedDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDPROFILEDEFINES_h 2 | #define ANTPLUS_BICYCLESPEEDPROFILEDEFINES_h 3 | 4 | #define ANTPLUS_BICYCLESPEED_DEVICETYPE 123 5 | 6 | 7 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_DEFAULT_NUMBER 0 8 | 9 | 10 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_CUMULATIVEOPERATINGTIME_NUMBER 1 11 | 12 | 13 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_MANUFACTURERID_NUMBER 2 14 | 15 | 16 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_PRODUCTID_NUMBER 3 17 | 18 | 19 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_NUMBER 4 20 | 21 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_NEW 1 22 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_GOOD 2 23 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_OK 3 24 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_LOW 4 25 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_CRITICAL 5 26 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_INVALID 7 27 | 28 | 29 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_MOTIONANDSPEED_NUMBER 5 30 | 31 | #define ANTPLUS_BICYCLESPEED_DATAPAGE_MOTIONANDSPEED_FLAGS_STOPINDICATOR 1 32 | 33 | #endif // ANTPLUS_BICYCLESPEEDPROFILEDEFINES_h 34 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/Profiles/ANTPLUS_ProfileBicycleSpeedSensor.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEBICYCLESPEEDSENSOR_h 2 | #define ANTPLUS_PROFILEBICYCLESPEEDSENSOR_h 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | // TODO 9 | class ProfileBicycleSpeedSensor : BaseMasterProfile { 10 | public: 11 | // void onHeartRateCapabilities(void (*func)(HeartRateCapabilities&, uintptr_t), uintptr_t data = 0) { _onHeartRateCapabilities.set(func, data); } 12 | // void onRequestDataPage(void (*func)(RequestDataPage&, uintptr_t), uintptr_t data = 0) { _onRequestDataPage.set(func, data); } 13 | // void begin(); 14 | // void stop(); 15 | // protected: 16 | // void onAcknowledgedData(AcknowledgedData& msg); 17 | // void onBroadcastData(BroadcastData& msg); 18 | // void transmitNextDataPage(); 19 | // private: 20 | // bool handleCapabilities(HeartRateBaseMainDataPage& dataPage); 21 | // bool handleRequestDataPage(HeartRateBaseMainDataPage& dataPage); 22 | // Callback _onHeartRateCapabilities; 23 | // Callback _onRequestDataPage; 24 | }; 25 | 26 | #endif // ANTPLUS_PROFILEBICYCLESPEEDSENSOR_h 27 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecGeneralSettingsPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECGENERALSEETTINGSPAGE_h 2 | #define ANTPLUS_FECGENERALSEETTINGSPAGE_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseGeneralSettingsPage : virtual public CoreDataPage { 8 | public: 9 | FecBaseGeneralSettingsPage(); 10 | uint8_t getCycleLength(); 11 | uint16_t getIncline(); 12 | uint8_t getResistanceLevel(); 13 | // Capability bits are reserved 14 | uint8_t getFeState(); 15 | uint8_t getLapToggleBit(); 16 | }; 17 | 18 | class FecGeneralSettingsPage : public FecBaseMainDataPage, public FecBaseGeneralSettingsPage { 19 | public: 20 | explicit FecGeneralSettingsPage(AntRxDataResponse& dp); 21 | }; 22 | 23 | class FecGeneralSettingsPageMsg : public FecBaseMainDataPageMsg, public FecBaseGeneralSettingsPage { 24 | public: 25 | FecGeneralSettingsPageMsg(); 26 | void setCycleLength(uint8_t cycleLength); 27 | void setIncline(uint16_t incline); 28 | void setResistanceLevel(uint8_t resistanceLevel); 29 | // Capability bits are reserved 30 | void setFeState(uint8_t state); 31 | void setLapToggleBit(uint8_t toggle); 32 | }; 33 | 34 | #endif // ANTPLUS_FECGENERALSETTINGSPAGE_h 35 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateSwimIntervalSummary.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATESWIMINTERVALSUMMARY_h 2 | #define ANTPLUS_HEARTRATESWIMINTERVALSUMMARY_h 3 | 4 | #include 5 | #include 6 | 7 | template 8 | class HeartRateBaseSwimIntervalSummary : virtual public CoreDataPage { 9 | public: 10 | HeartRateBaseSwimIntervalSummary(); 11 | uint8_t getIntervalAverageHeartRate(); 12 | uint8_t getIntervalMaximumHeartRate(); 13 | uint8_t getSessionAverageHeartRate(); 14 | }; 15 | 16 | class HeartRateSwimIntervalSummary : public HeartRateBaseMainDataPage, public HeartRateBaseSwimIntervalSummary { 17 | public: 18 | explicit HeartRateSwimIntervalSummary(AntRxDataResponse& dp); 19 | }; 20 | 21 | class HeartRateSwimIntervalSummaryMsg : public HeartRateBaseMainDataPageMsg, public HeartRateBaseSwimIntervalSummary { 22 | public: 23 | HeartRateSwimIntervalSummaryMsg(); 24 | void setIntervalAverageHeartRate(uint8_t intervalAverage); 25 | void setIntervalMaximumHeartRate(uint8_t intervalMaximum); 26 | void setSessionAverageHeartRate(uint8_t sessionAverage); 27 | }; 28 | 29 | #endif // ANTPLUS_HEARTRATESWIMINTERVALSUMMARY_h 30 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseDataPageMsg.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BASEDATAPAGEMSG_h 2 | #define ANTPLUS_BASEDATAPAGEMSG_h 3 | 4 | #include 5 | 6 | template 7 | class BaseDataPageMsg : virtual public CoreDataPage { 8 | public: 9 | BaseDataPageMsg(); 10 | #ifndef UNIT_TEST 11 | protected: 12 | #endif // UNIT_TEST 13 | uint8_t get8BitValue(uint8_t byte, uint8_t mask = 0xFF, uint8_t shift = 0) override; 14 | uint16_t get16BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint16_t mask = 0xFFFF, uint8_t shift = 0) override; 15 | uint32_t get24BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFF, uint8_t shift = 0) override; 16 | uint32_t get32BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFFFF, uint8_t shift = 0) override; 17 | void set8BitValue(uint8_t value, uint8_t byte, uint8_t mask = 0xFF, uint8_t shift = 0); 18 | void set16BitValue(uint16_t value, uint8_t lsb_byte, uint8_t msb_byte, uint16_t mask = 0xFFFF, uint8_t shift = 0); 19 | void set24BitValue(uint32_t value, uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFF, uint8_t shift = 0); 20 | void set32BitValue(uint32_t value, uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask = 0xFFFFFFFF, uint8_t shift = 0); 21 | }; 22 | 23 | #endif // ANTPLUS_BASEDATAPAGEMSG_h 24 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerStandardCrankTorque.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERSTANDARDCRANKTORQUE_h 2 | #define ANTPLUS_BICYCLEPOWERSTANDARDCRANKTORQUE_h 3 | 4 | #include 5 | 6 | template 7 | class BicyclePowerBaseStandardCrankTorque : virtual public CoreDataPage { 8 | public: 9 | BicyclePowerBaseStandardCrankTorque(); 10 | uint8_t getCrankTicks(); 11 | uint8_t getInstantaneousCadence(); 12 | uint16_t getCrankPeriod(); 13 | uint16_t getAccumulatedTorque(); 14 | }; 15 | 16 | class BicyclePowerStandardCrankTorque : 17 | public BicyclePowerBaseMainDataPage, 18 | public BicyclePowerBaseStandardCrankTorque { 19 | public: 20 | explicit BicyclePowerStandardCrankTorque(AntRxDataResponse& dp); 21 | }; 22 | 23 | class BicyclePowerStandardCrankTorqueMsg : 24 | public BicyclePowerBaseMainDataPageMsg, 25 | public BicyclePowerBaseStandardCrankTorque { 26 | public: 27 | BicyclePowerStandardCrankTorqueMsg(); 28 | void setCrankTicks(uint8_t ticks); 29 | void setInstantaneousCadence(uint8_t cadence); 30 | void setCrankPeriod(uint16_t period); 31 | void setAccumulatedTorque(uint16_t torque); 32 | }; 33 | 34 | #endif // ANTPLUS_BICYCLEPOWERSTANDARDCRANKTORQUE_h 35 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerStandardWheelTorque.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERSTANDARDWHEELTORQUE_h 2 | #define ANTPLUS_BICYCLEPOWERSTANDARDWHEELTORQUE_h 3 | 4 | #include 5 | 6 | template 7 | class BicyclePowerBaseStandardWheelTorque : virtual public CoreDataPage { 8 | public: 9 | BicyclePowerBaseStandardWheelTorque(); 10 | uint8_t getWheelTicks(); 11 | uint8_t getInstantaneousCadence(); 12 | uint16_t getWheelPeriod(); 13 | uint16_t getAccumulatedTorque(); 14 | }; 15 | 16 | class BicyclePowerStandardWheelTorque : 17 | public BicyclePowerBaseMainDataPage, 18 | public BicyclePowerBaseStandardWheelTorque { 19 | public: 20 | explicit BicyclePowerStandardWheelTorque(AntRxDataResponse& dp); 21 | }; 22 | 23 | class BicyclePowerStandardWheelTorqueMsg : 24 | public BicyclePowerBaseMainDataPageMsg, 25 | public BicyclePowerBaseStandardWheelTorque { 26 | public: 27 | BicyclePowerStandardWheelTorqueMsg(); 28 | void setWheelTicks(uint8_t ticks); 29 | void setInstantaneousCadence(uint8_t cadence); 30 | void setWheelPeriod(uint16_t period); 31 | void setAccumulatedTorque(uint16_t torque); 32 | }; 33 | 34 | #endif // ANTPLUS_BICYCLEPOWERSTANDARDWHEELTORQUE_h 35 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateCumulativeOperatingTime.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define TIME_LSB_BYTE 1 5 | #define TIME_MSB_BYTE 3 6 | 7 | template 8 | HeartRateBaseCumulativeOperatingTime::HeartRateBaseCumulativeOperatingTime() : 9 | CoreDataPage() {} 10 | 11 | template 12 | uint32_t HeartRateBaseCumulativeOperatingTime::getCumulativeOperatingTime() { 13 | return this->get24BitValue(TIME_LSB_BYTE, TIME_MSB_BYTE); 14 | } 15 | 16 | template class HeartRateBaseCumulativeOperatingTime; 17 | template class HeartRateBaseCumulativeOperatingTime; 18 | 19 | HeartRateCumulativeOperatingTime::HeartRateCumulativeOperatingTime(AntRxDataResponse& dp) : 20 | HeartRateBaseMainDataPage(dp), 21 | HeartRateBaseCumulativeOperatingTime() {} 22 | 23 | HeartRateCumulativeOperatingTimeMsg::HeartRateCumulativeOperatingTimeMsg() : 24 | HeartRateBaseMainDataPageMsg(HEARTRATE_CUMULATIVEOPERATINGTIME_NUMBER), 25 | HeartRateBaseCumulativeOperatingTime() {} 26 | 27 | void HeartRateCumulativeOperatingTimeMsg::setCumulativeOperatingTime(uint32_t time) { 28 | set24BitValue(time, TIME_LSB_BYTE, TIME_MSB_BYTE); 29 | } 30 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLESPEEDBASEMAINDATAPAGE_h 2 | #define ANTPLUS_BICYCLESPEEDBASEMAINDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | template 8 | class BicycleSpeedCoreMainDataPage : virtual public CoreDataPage { 9 | public: 10 | BicycleSpeedCoreMainDataPage(); 11 | uint8_t getDataPageNumber() override; 12 | uint8_t getPageChangeToggle(); 13 | uint16_t getBikeSpeedEventTime(); 14 | uint16_t getCumulativeSpeedRevolutionCount(); 15 | }; 16 | 17 | class BicycleSpeedBaseMainDataPage : public BaseDataPage, public BicycleSpeedCoreMainDataPage { 18 | public: 19 | explicit BicycleSpeedBaseMainDataPage(AntRxDataResponse& dp); 20 | }; 21 | 22 | class BicycleSpeedBaseMainDataPageMsg : public BaseDataPageMsg, public BicycleSpeedCoreMainDataPage { 23 | public: 24 | explicit BicycleSpeedBaseMainDataPageMsg(uint8_t dataPageNumber); 25 | void setPageChangeToggle(uint8_t toggle); 26 | void setBikeSpeedEventTime(uint16_t time); 27 | void setCumulativeSpeedRevolutionCount(uint16_t count); 28 | protected: 29 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 30 | }; 31 | 32 | #endif // ANTPLUS_BICYCLESPEEDBASEMAINDATAPAGE_h 33 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevSpeedSystemInformation1.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVSPEEDSYSTEMINFORMATION1_h 2 | #define ANTPLUS_LEVSPEEDSYSTEMINFORMATION1_h 3 | 4 | #include 5 | 6 | template 7 | class LevBaseSpeedSystemInformation1 : virtual public CoreDataPage { 8 | public: 9 | LevBaseSpeedSystemInformation1(); 10 | uint8_t getBatteryTemperatureState(); 11 | uint8_t getBatteryTemperatureAlert(); 12 | uint8_t getMotorTemperatureState(); 13 | uint8_t getMotorTemperatureAlert(); 14 | uint8_t getErrorMessage(); 15 | }; 16 | 17 | class LevSpeedSystemInformation1 : public LevBaseSpeedSystemInformation, public LevBaseSpeedSystemInformation1 { 18 | public: 19 | explicit LevSpeedSystemInformation1(AntRxDataResponse& dp); 20 | }; 21 | 22 | class LevSpeedSystemInformation1Msg : public LevBaseSpeedSystemInformationMsg, public LevBaseSpeedSystemInformation1 { 23 | public: 24 | LevSpeedSystemInformation1Msg(); 25 | void setBatteryTemperatureState(uint8_t state); 26 | void setBatteryTemperatureAlert(uint8_t alert); 27 | void setMotorTemperatureState(uint8_t state); 28 | void setMotorTemperatureAlert(uint8_t alert); 29 | void setErrorMessage(uint8_t err); 30 | }; 31 | 32 | #endif // ANTPLUS_LEVSPEEDSYSTEMINFORMATION1_h 33 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateBaseMainDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEBASEMAINDATAPAGE_h 2 | #define ANTPLUS_HEARTRATEBASEMAINDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | template 8 | class HeartRateCoreMainDataPage : virtual public CoreDataPage { 9 | public: 10 | HeartRateCoreMainDataPage(); 11 | uint8_t getDataPageNumber() override; 12 | uint8_t getPageChangeToggle(); 13 | uint16_t getHeartBeatEventTime(); 14 | uint8_t getHeartBeatCount(); 15 | uint8_t getComputedHeartRate(); 16 | }; 17 | 18 | class HeartRateBaseMainDataPage : public BaseDataPage, public HeartRateCoreMainDataPage { 19 | public: 20 | explicit HeartRateBaseMainDataPage(AntRxDataResponse& dp); 21 | }; 22 | 23 | class HeartRateBaseMainDataPageMsg : public BaseDataPageMsg, public HeartRateCoreMainDataPage { 24 | public: 25 | explicit HeartRateBaseMainDataPageMsg(uint8_t dataPageNumber); 26 | void setPageChangeToggle(uint8_t toggle); 27 | void setHeartBeatEventTime(uint16_t time); 28 | void setHeartBeatCount(uint8_t count); 29 | void setComputedHeartRate(uint8_t heartRate); 30 | protected: 31 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 32 | }; 33 | 34 | #endif // ANTPLUS_HEARTRATEBASEMAINDATAPAGE_h 35 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ModeSettings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define SPORTSMODE_BYTE 7 6 | #define RESERVED_VALUE 0xFF 7 | 8 | template 9 | BaseModeSettings::BaseModeSettings() : CoreDataPage() {} 10 | 11 | template 12 | uint8_t BaseModeSettings::getSportMode() { 13 | return this->get8BitValue(SPORTSMODE_BYTE); 14 | } 15 | 16 | template class BaseModeSettings; 17 | template class BaseModeSettings; 18 | 19 | ModeSettings::ModeSettings(AntRxDataResponse& dp) : 20 | BaseDataPage(dp), 21 | BaseModeSettings() {} 22 | 23 | ModeSettingsMsg::ModeSettingsMsg() : 24 | BaseDataPageMsg(), 25 | BaseModeSettings() { 26 | setDataBuffer(_buffer); 27 | set8BitValue(ANTPLUS_COMMON_DATAPAGE_MODESETTINGS_NUMBER, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 28 | set8BitValue(RESERVED_VALUE, 1); 29 | set8BitValue(RESERVED_VALUE, 2); 30 | set8BitValue(RESERVED_VALUE, 3); 31 | set8BitValue(RESERVED_VALUE, 4); 32 | set8BitValue(RESERVED_VALUE, 5); 33 | set8BitValue(RESERVED_VALUE, 6); 34 | } 35 | 36 | void ModeSettingsMsg::setSportMode(uint8_t sportsMode) { 37 | set8BitValue(sportsMode, SPORTSMODE_BYTE); 38 | } 39 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerStandardPowerOnly.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERSTANDARDPOWERONLY_h 2 | #define ANTPLUS_BICYCLEPOWERSTANDARDPOWERONLY_h 3 | 4 | #include 5 | 6 | template 7 | class BicyclePowerBaseStandardPowerOnly : virtual public CoreDataPage { 8 | public: 9 | BicyclePowerBaseStandardPowerOnly(); 10 | uint8_t getPedalPower(); 11 | uint8_t getPedalDifferentiation(); 12 | uint8_t getInstantaneousCadence(); 13 | uint16_t getAccumulatedPower(); 14 | uint16_t getInstantaneousPower(); 15 | }; 16 | 17 | class BicyclePowerStandardPowerOnly : public BicyclePowerBaseMainDataPage, public BicyclePowerBaseStandardPowerOnly { 18 | public: 19 | explicit BicyclePowerStandardPowerOnly(AntRxDataResponse& dp); 20 | }; 21 | 22 | class BicyclePowerStandardPowerOnlyMsg : public BicyclePowerBaseMainDataPageMsg, public BicyclePowerBaseStandardPowerOnly { 23 | public: 24 | BicyclePowerStandardPowerOnlyMsg(void); 25 | void setPedalPower(uint8_t pedalPower); 26 | void setPedalDifferentiation(uint8_t differentiation); 27 | void setInstantaneousCadence(uint8_t cadence); 28 | void setAccumulatedPower(uint16_t accPower); 29 | void setInstantaneousPower(uint16_t instantaneousPower); 30 | }; 31 | 32 | #endif // ANTPLUS_BICYCLEPOWERSTANDARDPOWERONLY_h 33 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecTargetPower.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define TARGET_POWER_LSB_BYTE 6 5 | #define TARGET_POWER_MSB_BYTE 7 6 | #define RESERVED0_LSB_BYTE 1 7 | #define RESERVED0_MSB_BYTE 4 8 | #define RESERVED0_VALUE 0xFFFFFFFF 9 | #define RESERVED1_BYTE 5 10 | #define RESERVED1_VALUE 0xFF 11 | 12 | template 13 | FecBaseTargetPower::FecBaseTargetPower() : 14 | CoreDataPage() {} 15 | 16 | template 17 | uint16_t FecBaseTargetPower::getTargetPower() { 18 | return this->get16BitValue(TARGET_POWER_LSB_BYTE, TARGET_POWER_MSB_BYTE); 19 | } 20 | 21 | template class FecBaseTargetPower; 22 | template class FecBaseTargetPower; 23 | 24 | FecTargetPower::FecTargetPower(AntRxDataResponse& dp) : 25 | FecBaseMainDataPage(dp), 26 | FecBaseTargetPower() {} 27 | 28 | FecTargetPowerMsg::FecTargetPowerMsg() : 29 | FecBaseMainDataPageMsg(ANTPLUS_FEC_DATAPAGE_TARGETPOWER_NUMBER), 30 | FecBaseTargetPower() { 31 | set32BitValue(RESERVED0_VALUE, RESERVED0_LSB_BYTE, RESERVED0_MSB_BYTE); 32 | set8BitValue(RESERVED1_VALUE, RESERVED1_BYTE); 33 | } 34 | 35 | void FecTargetPowerMsg::setTargetPower(uint16_t targetPower) { 36 | set16BitValue(targetPower, TARGET_POWER_LSB_BYTE, TARGET_POWER_MSB_BYTE); 37 | } 38 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/DataPages/ANTPLUS_MuscleOxygenMuscleOxygenData.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MUSCLEOXYGENMUSCLEOXYGENDATA_h 2 | #define ANTPLUS_MUSCLEOXYGENMUSCLEOXYGENDATA_h 3 | 4 | #include 5 | 6 | template 7 | class MuscleOxygenBaseMuscleOxygenData : public virtual CoreDataPage { 8 | public: 9 | MuscleOxygenBaseMuscleOxygenData(); 10 | uint8_t getEventCount(); 11 | uint8_t getNotifications(); 12 | uint8_t getAntFSSupport(); 13 | uint8_t getMeasurementInterval(); 14 | uint16_t getTotalHemoglobinConcentration(); 15 | uint16_t getPreviousSaturatedHemoglobinPercentage(); 16 | uint16_t getCurrentSaturatedHemoglobinPercentage(); 17 | }; 18 | 19 | class MuscleOxygenMuscleOxygenDataMsg : public MuscleOxygenBaseMainDataPageMsg, public MuscleOxygenBaseMuscleOxygenData { 20 | public: 21 | MuscleOxygenMuscleOxygenDataMsg(); 22 | void setEventCount(uint8_t n); 23 | void setNotifications(uint8_t notficications); 24 | void setAntFSSupport(uint8_t support); 25 | void setMeasurementInterval(uint8_t interval); 26 | void setTotalHemoglobinConcentration(uint16_t concentration); 27 | void setPreviousSaturatedHemoglobinPercentage(uint16_t percent); 28 | void setCurrentSaturatedHemoglobinPercentage(uint16_t percent); 29 | }; 30 | 31 | #endif // ANTPLUS_MUSCLEOXYGENMUSCLEOXYGENDATA_h 32 | -------------------------------------------------------------------------------- /src/MainClasses/ANTPLUS_CallbackWorkAround.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_CALLBACKWORKAROUND_h 2 | #define ANTPLUS_CALLBACKWORKAROUND_h 3 | #include "ANT.h" 4 | 5 | /* This file is a workaround for the function pointers, I apologize for it, its not pretty */ 6 | 7 | void onPacketErrorCallback(uint8_t error, uintptr_t data); 8 | void onAcknowledgedDataCallback(AcknowledgedData& msg, uintptr_t data); 9 | void onAdvancedBurstDataCallback(AdvancedBurstData& msg, uintptr_t data); 10 | void onBroadcastDataCallback(BroadcastData& msg, uintptr_t data); 11 | void onBurstTransferDataCallback(BurstTransferData& msg, uintptr_t data); 12 | void onAdvancedBurstCapabilitiesConfigurationCallback(AdvancedBurstCapabilitiesConfiguration& msg, uintptr_t data); 13 | void onAntVersionCallback(AntVersion& msg, uintptr_t data); 14 | void onCapabilitiesCallback(Capabilities& msg, uintptr_t data); 15 | void onChannelEventResponseCallback(ChannelEventResponse& msg, uintptr_t data); 16 | void onChannelIdResponseCallback(ChannelIdResponse& msg, uintptr_t data); 17 | void onChannelStatusCallback(ChannelStatus& msg, uintptr_t data); 18 | void onEncryptionModeParametersCallback(EncryptionModeParameters& msg, uintptr_t data); 19 | void onEventFilterCallback(EventFilter& msg, uintptr_t data); 20 | void onSelectiveDataUpdateMaskSettingCallback(SelectiveDataUpdateMaskSetting& msg, uintptr_t data); 21 | void onStartUpMessageCallback(StartUpMessage& msg, uintptr_t data); 22 | 23 | #endif // ANTPLUS_CALLBACKWORKAROUND_h -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecBasicResistance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define RESERVED0_LSB_BYTE 1 5 | #define RESERVED0_MSB_BYTE 4 6 | #define RESERVED0_VALUE 0xFFFFFFFF 7 | #define RESERVED1_LSB_BYTE 5 8 | #define RESERVED1_MSB_BYTE 6 9 | #define RESERVED1_VALUE 0xFFFF 10 | #define TOTAL_RESISTANCE_BYTE 7 11 | 12 | template 13 | FecBaseBasicResistance::FecBaseBasicResistance() : 14 | CoreDataPage() {} 15 | 16 | template 17 | uint8_t FecBaseBasicResistance::getTotalResistance() { 18 | return this->get8BitValue(TOTAL_RESISTANCE_BYTE); 19 | } 20 | 21 | template class FecBaseBasicResistance; 22 | template class FecBaseBasicResistance; 23 | 24 | FecBasicResistance::FecBasicResistance(AntRxDataResponse& dp) : 25 | FecBaseMainDataPage(dp), 26 | FecBaseBasicResistance() {} 27 | 28 | FecBasicResistanceMsg::FecBasicResistanceMsg() : 29 | FecBaseMainDataPageMsg(ANTPLUS_FEC_DATAPAGE_TRACKRESISTANCE_NUMBER), 30 | FecBaseBasicResistance() { 31 | set32BitValue(RESERVED0_VALUE, RESERVED0_LSB_BYTE, RESERVED0_MSB_BYTE); 32 | set16BitValue(RESERVED1_VALUE, RESERVED1_LSB_BYTE, RESERVED1_MSB_BYTE); 33 | } 34 | 35 | void FecBasicResistanceMsg::setTotalResistance(uint8_t totalResistance) { 36 | set8BitValue(totalResistance, TOTAL_RESISTANCE_BYTE); 37 | } 38 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/ANTPLUS_MuscleOxygenDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MUSCLEOXYGENDEFINES_h 2 | #define ANTPLUS_MUSCLEOXYGENDEFINES_h 3 | 4 | #define ANTPLUS_MUSCLEOXYGEN_DEVICETYPE 31 5 | 6 | #define ANTPLUS_MUSCLEOXYGEN_FLAGS_BATTERYSTATUS_SUPPORTED (1 << 0) 7 | 8 | 9 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_NUMBER 1 10 | 11 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_NOTIFICATIONS_UTCTIMEREQUIRED 1 12 | 13 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_CAPABILITIES_ANTFSSUPPORT_SUPPORTED 1 14 | 15 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_CAPABILITIES_MEASUREMENTINTERVAL_250MS 1 16 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_CAPABILITIES_MEASUREMENTINTERVAL_500MS 2 17 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_CAPABILITIES_MEASUREMENTINTERVAL_1S 3 18 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_CAPABILITIES_MEASUREMENTINTERVAL_2S 4 19 | 20 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_TOTALHEMOGLOBINCONCENTRATION_AMBIENTLIGHTOOHIGH 0xFFE 21 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_TOTALHEMOGLOBINCONCENTRATION_INVALID 0xFFF 22 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_PREVIOUSSATURATEDHEMOGLOBINPERCENTAGE_INVALID 0xFFF 23 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_CURRENTSATURATEDHEMOGLOBINPERCENTAGE_INVALID 0xFFF 24 | 25 | 26 | #define ANTPLUS_MUSCLEOXYGEN_DATAPAGE_COMMANDS_NUMBER 16 27 | 28 | #endif // ANTPLUS_MUSCLEOXYGENDEFINES_h 29 | -------------------------------------------------------------------------------- /test/test_heart-rate-display/Test_HeartRateDisplayDefaultDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include "unity.h" 2 | #include "Util/Testing.h" 3 | #include "ANTPLUS.h" 4 | 5 | #ifdef UNIT_TEST 6 | 7 | /** 8 | * This tests the functionlity of the base page since 9 | * it has no specific implementation details 10 | */ 11 | 12 | uint8_t mockedInput[] = {0, 0x80, 0xFF, 0xFF, 0xFF, 0xAB, 0xCD, 0x12, 0x45}; 13 | HeartRateDefault *dp; 14 | 15 | void test_datapage(void) { 16 | TEST_ASSERT_EQUAL_UINT8(0, dp->getDataPageNumber()); 17 | } 18 | 19 | void test_pageChangeToggle(void) { 20 | TEST_ASSERT_EQUAL_UINT8(1, dp->getPageChangeToggle()); 21 | } 22 | 23 | void test_heartBeatEventTime(void) { 24 | TEST_ASSERT_EQUAL_UINT16(0xCDAB, dp->getHeartBeatEventTime()); 25 | } 26 | 27 | void test_heartBeatCount(void) { 28 | TEST_ASSERT_EQUAL_UINT8(0x12, dp->getHeartBeatCount()); 29 | } 30 | 31 | void test_computerHeartRate(void) { 32 | TEST_ASSERT_EQUAL_UINT8(0x45, dp->getComputedHeartRate()); 33 | } 34 | 35 | int main(int argc, char **argv) { 36 | BroadcastData bd; 37 | bd.setFrameData(mockedInput); 38 | dp = new HeartRateDefault(bd); 39 | // force data into buffer for testing purposes 40 | 41 | UNITY_BEGIN(); 42 | RUN_TEST(test_datapage); 43 | RUN_TEST(test_pageChangeToggle); 44 | RUN_TEST(test_heartBeatEventTime); 45 | RUN_TEST(test_heartBeatCount); 46 | RUN_TEST(test_computerHeartRate); 47 | UNITY_END(); 48 | 49 | return 0; 50 | } 51 | 52 | #endif // UNIT_TEST 53 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedBatteryStatus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define FRACTIONALBATTERYVOLTAGE_BYTE 2 5 | #define COARSEBATTERYVOLTAGE_BYTE 3 6 | #define BATTERYSTATUS_BYTE 3 7 | #define COARSEBATTERYVOLTAGE_MASK 0x0F 8 | #define BATTERYSTATUS_MASK 0x70 9 | #define BATTERYSTATUS_SHIFT 4 10 | 11 | template 12 | BicycleSpeedBaseBatteryStatus::BicycleSpeedBaseBatteryStatus() : 13 | CoreDataPage() {} 14 | 15 | template 16 | uint8_t BicycleSpeedBaseBatteryStatus::getFractionalBatteryVoltage() { 17 | return this->get8BitValue(FRACTIONALBATTERYVOLTAGE_BYTE); 18 | } 19 | 20 | template 21 | uint8_t BicycleSpeedBaseBatteryStatus::getCoarseBatteryVoltage() { 22 | return this->get8BitValue(COARSEBATTERYVOLTAGE_BYTE, 23 | COARSEBATTERYVOLTAGE_MASK); 24 | } 25 | 26 | template 27 | uint8_t BicycleSpeedBaseBatteryStatus::getBatteryStatus() { 28 | return this->get8BitValue(BATTERYSTATUS_BYTE, BATTERYSTATUS_MASK, 29 | BATTERYSTATUS_SHIFT); 30 | } 31 | 32 | template class BicycleSpeedBaseBatteryStatus; 33 | template class BicycleSpeedBaseBatteryStatus; 34 | 35 | BicycleSpeedBatteryStatus::BicycleSpeedBatteryStatus(AntRxDataResponse& dp) : 36 | BicycleSpeedBaseMainDataPage(dp), 37 | BicycleSpeedBaseBatteryStatus() {} 38 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_BatteryStatus.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BATTERYSTATUS_h 2 | #define ANTPLUS_BATTERYSTATUS_h 3 | 4 | #include 5 | #include 6 | 7 | // Common page 82 8 | 9 | template 10 | class BaseBatteryStatus : virtual public CoreDataPage { 11 | public: 12 | BaseBatteryStatus(); 13 | uint8_t getNumberOfBatteries(); 14 | uint8_t getBatteryIdentifier(); 15 | uint32_t getCumulativeOperatingTime(); 16 | uint8_t getFractionalBatteryVoltage(); 17 | uint8_t getCoarseBatteryVoltage(); 18 | uint8_t getBatteryStatus(); 19 | uint8_t getCumulativeOperatingTimeResolution(); 20 | }; 21 | 22 | class BatteryStatus : public BaseDataPage, public BaseBatteryStatus { 23 | public: 24 | explicit BatteryStatus(AntRxDataResponse& dp); 25 | }; 26 | 27 | class BatteryStatusMsg : public BaseDataPageMsg, public BaseBatteryStatus { 28 | public: 29 | BatteryStatusMsg(); 30 | void setNumberOfBatteries(uint8_t num); 31 | void setBatteryIdentifier(uint8_t id); 32 | void setCumulativeOperatingTime(uint32_t time); 33 | void setFractionalBatteryVoltage(uint8_t voltage); 34 | void setCoarseBatteryVoltage(uint8_t voltage); 35 | void setBatteryStatus(uint8_t status); 36 | void setCumulativeOperatingTimeResolution(uint8_t resolution); 37 | private: 38 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 39 | }; 40 | 41 | #endif // ANTPLUS_BATTERYSTATUS_h 42 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevSpeedDistanceInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define REMAININGRANGE_LSB_BYTE 4 5 | #define REMAININGRANGE_MSB_BYTE 5 6 | #define REMAININGRANGE_MASK 0x0FFF 7 | 8 | /* Speed and Distance */ 9 | template 10 | LevInternalSpeedDistanceInformation::LevInternalSpeedDistanceInformation() : 11 | CoreDataPage() {} 12 | 13 | template 14 | uint16_t LevInternalSpeedDistanceInformation::getRemainingRange() { // in km 15 | return this->get16BitValue(REMAININGRANGE_LSB_BYTE, REMAININGRANGE_MSB_BYTE, 16 | REMAININGRANGE_MASK); 17 | } 18 | 19 | template class LevInternalSpeedDistanceInformation; 20 | template class LevInternalSpeedDistanceInformation; 21 | 22 | LevSpeedDistanceInformation::LevSpeedDistanceInformation(AntRxDataResponse& dp) : 23 | LevBaseSpeedDistanceInformation(dp), 24 | LevInternalSpeedDistanceInformation() {} 25 | 26 | LevSpeedDistanceInformationMsg::LevSpeedDistanceInformationMsg() : 27 | LevBaseSpeedDistanceInformationMsg(ANTPLUS_LEV_DATAPAGE_SPEEDDISTANCEINFORMATION_NUMBER), 28 | LevInternalSpeedDistanceInformation() {} 29 | 30 | void LevSpeedDistanceInformationMsg::setRemainingRange(uint16_t remainingRange) { // in km 31 | set16BitValue(remainingRange, REMAININGRANGE_LSB_BYTE, REMAININGRANGE_MSB_BYTE, 32 | REMAININGRANGE_MASK); 33 | } 34 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecGeneralFeData.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECGENERALFEDATA_h 2 | #define ANTPLUS_FECGENERALFEDATA_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseGeneralFeData : virtual public CoreDataPage { 8 | public: 9 | FecBaseGeneralFeData(); 10 | uint8_t getFeType(); 11 | uint8_t getElapsedTime(); 12 | uint8_t getDistanceTraveled(); 13 | uint16_t getSpeed(); 14 | uint8_t getHeartRate(); 15 | uint8_t getHrDataSource(); 16 | uint8_t getDistanceTraveledEnabled(); 17 | uint8_t getVirtualSpeedFlag(); 18 | uint8_t getFeState(); 19 | uint8_t getLapToggleBit(); 20 | }; 21 | 22 | class FecGeneralFeData : public FecBaseMainDataPage, public FecBaseGeneralFeData { 23 | public: 24 | explicit FecGeneralFeData(AntRxDataResponse& dp); 25 | }; 26 | 27 | class FecGeneralFeDataMsg : public FecBaseMainDataPageMsg, public FecBaseGeneralFeData { 28 | public: 29 | FecGeneralFeDataMsg(); 30 | void setFeType(uint8_t fe_type); 31 | void setElapsedTime(uint8_t time); 32 | void setDistanceTraveled(uint8_t distance); 33 | void setSpeed(uint16_t speed); 34 | void setHeartRate(uint8_t hr); 35 | void setHrDataSource(uint8_t source); 36 | void setDistanceTraveledEnabled(uint8_t enabled); 37 | void setVirtualSpeedFlag(uint8_t real); 38 | void setFeState(uint8_t state); 39 | void setLapToggleBit(uint8_t toggle); 40 | }; 41 | 42 | 43 | #endif // ANTPLUS_FECGENERALFEDATA_h 44 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateCapabilities.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define FEATURESSUPPORTED_BYTE 2 5 | #define FEATURESENABLED_BYTE 3 6 | #define FEATURES_MASK 0xC7 7 | 8 | template 9 | HeartRateBaseCapabilities::HeartRateBaseCapabilities() : 10 | CoreDataPage() {} 11 | 12 | template 13 | uint8_t HeartRateBaseCapabilities::getFeaturesSupported() { 14 | return this->get8BitValue(FEATURESSUPPORTED_BYTE); 15 | } 16 | 17 | template 18 | uint8_t HeartRateBaseCapabilities::getFeaturesEnabled() { 19 | return this->get8BitValue(FEATURESENABLED_BYTE); 20 | } 21 | 22 | template class HeartRateBaseCapabilities; 23 | template class HeartRateBaseCapabilities; 24 | 25 | HeartRateCapabilities::HeartRateCapabilities(AntRxDataResponse& dp) : 26 | HeartRateBaseMainDataPage(dp), 27 | HeartRateBaseCapabilities() {} 28 | 29 | HeartRateCapabilitiesMsg::HeartRateCapabilitiesMsg() : 30 | HeartRateBaseMainDataPageMsg(ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_NUMBER), 31 | HeartRateBaseCapabilities() {} 32 | 33 | void HeartRateCapabilitiesMsg::setFeaturesSupported(uint8_t supported) { 34 | set8BitValue(supported, FEATURESSUPPORTED_BYTE, FEATURES_MASK); 35 | } 36 | 37 | void HeartRateCapabilitiesMsg::setFeaturesEnabled(uint8_t enabled) { 38 | set8BitValue(enabled, FEATURESENABLED_BYTE, FEATURES_MASK); 39 | } 40 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerTorqueEffectivenessAndPedalSmoothness.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERPEDALSMOOTHNESS_h 2 | #define ANTPLUS_BICYCLEPOWERPEDALSMOOTHNESS_h 3 | 4 | #include 5 | 6 | template 7 | class BicyclePowerBaseTorqueEffectivenessAndPedalSmoothness : 8 | virtual public CoreDataPage { 9 | public: 10 | BicyclePowerBaseTorqueEffectivenessAndPedalSmoothness(); 11 | uint8_t getLeftTorqueEffectiveness(); 12 | uint8_t getRightTorqueEffectiveness(); 13 | uint8_t getLeftPedalSmoothness(); 14 | uint8_t getRightPedalSmoothness(); 15 | }; 16 | 17 | class BicyclePowerTorqueEffectivenessAndPedalSmoothness : 18 | public BicyclePowerBaseMainDataPage, 19 | public BicyclePowerBaseTorqueEffectivenessAndPedalSmoothness { 20 | public: 21 | explicit BicyclePowerTorqueEffectivenessAndPedalSmoothness(AntRxDataResponse& dp); 22 | }; 23 | 24 | class BicyclePowerTorqueEffectivenessAndPedalSmoothnessMsg : 25 | public BicyclePowerBaseMainDataPageMsg, 26 | public BicyclePowerBaseTorqueEffectivenessAndPedalSmoothness { 27 | public: 28 | BicyclePowerTorqueEffectivenessAndPedalSmoothnessMsg(); 29 | void setLeftTorqueEffectiveness(uint8_t effectiveness); 30 | void setRightTorqueEffectiveness(uint8_t effectiveness); 31 | void setLeftPedalSmoothness(uint8_t smoothness); 32 | void setRightPedalSmoothness(uint8_t smoothness); 33 | }; 34 | 35 | #endif // ANTPLUS_BICYCLEPOWERPEDALSMOOTHNESS_h 36 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevAltSpeedDistanceInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define FUELCONSUMPTION_LSB_BYTE 4 5 | #define FUELCONSUMPTION_MSB_BYTE 5 6 | #define FUELCONSUMPTION_MASK 0x0FFF 7 | 8 | /* Alt Speed and Distance */ 9 | template 10 | LevBaseAltSpeedDistanceInformation::LevBaseAltSpeedDistanceInformation() : 11 | CoreDataPage() {} 12 | 13 | template 14 | uint16_t LevBaseAltSpeedDistanceInformation::getFuelConsumption() // in Wh/km 15 | { 16 | return this->get16BitValue(FUELCONSUMPTION_LSB_BYTE, 17 | FUELCONSUMPTION_MSB_BYTE, FUELCONSUMPTION_MASK); 18 | } 19 | 20 | template class LevBaseAltSpeedDistanceInformation; 21 | template class LevBaseAltSpeedDistanceInformation; 22 | 23 | LevAltSpeedDistanceInformation::LevAltSpeedDistanceInformation(AntRxDataResponse& dp) : 24 | LevBaseSpeedDistanceInformation(dp), 25 | LevBaseAltSpeedDistanceInformation() {} 26 | 27 | LevAltSpeedDistanceInformationMsg::LevAltSpeedDistanceInformationMsg() : 28 | LevBaseSpeedDistanceInformationMsg(ANTPLUS_LEV_DATAPAGE_ALTSPEEDDISTANCEINFORMATION_NUMBER), 29 | LevBaseAltSpeedDistanceInformation() {} 30 | 31 | void LevAltSpeedDistanceInformationMsg::setFuelConsumption(uint16_t consumption) // in Wh/km 32 | { 33 | set16BitValue(consumption, FUELCONSUMPTION_LSB_BYTE, 34 | FUELCONSUMPTION_MSB_BYTE, FUELCONSUMPTION_MASK); 35 | } 36 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_MultiComponentSystemProductInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MULTICOMPONENTSYSTEMPRODUCTINFORMATION_h 2 | #define ANTPLUS_MULTICOMPONENTSYSTEMPRODUCTINFORMATION_h 3 | 4 | #include 5 | #include 6 | 7 | // Common page 79 8 | 9 | template 10 | class BaseMultiComponentSystemProductInformation : virtual public CoreDataPage { 11 | public: 12 | BaseMultiComponentSystemProductInformation(); 13 | uint8_t getNumberOfComponents(); 14 | uint8_t getComponentIdentifier(); 15 | uint8_t getSWRevisionSupplemental(); 16 | uint8_t getSWRevisionMain(); 17 | uint32_t getSerialNumber(); 18 | }; 19 | 20 | class MultiComponentSystemProductInformation : public BaseDataPage, public BaseMultiComponentSystemProductInformation { 21 | public: 22 | explicit MultiComponentSystemProductInformation(AntRxDataResponse& dp); 23 | }; 24 | 25 | class MultiComponentSystemProductInformationMsg : public BaseDataPageMsg, public BaseMultiComponentSystemProductInformation { 26 | public: 27 | MultiComponentSystemProductInformationMsg(); 28 | void setNumberOfComponents(uint8_t count); 29 | void setComponentIdentifier(uint8_t identifier); 30 | void setSWRevisionSupplemental(uint8_t revision); 31 | void setSWRevisionMain(uint8_t revision); 32 | void setSerialNumber(uint32_t serialNumber); 33 | private: 34 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 35 | }; 36 | 37 | #endif // ANTPLUS_MULTICOMPONENTSYSTEMPRODUCTINFORMATION_h 38 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevBaseSpeedSystemInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVBASESPEEDSYSTEMINFORMATION_h 2 | #define ANTPLUS_LEVBASESPEEDSYSTEMINFORMATION_h 3 | 4 | #include 5 | 6 | template 7 | class LevCoreSpeedSystemInformation : virtual public CoreDataPage { 8 | public: 9 | LevCoreSpeedSystemInformation(); 10 | uint8_t getCurrentRegenerativeLevel(); 11 | uint8_t getCurrentAssistLevel(); 12 | uint8_t getSystemState(); 13 | uint8_t getCurrentFrontGear(); 14 | uint8_t getCurrentRearGear(); 15 | uint8_t getManualAutoState(); 16 | uint8_t getGearExist(); 17 | uint16_t getSpeed(); // in 1/10 km/h 18 | }; 19 | 20 | class LevBaseSpeedSystemInformation : public LevBaseMainDataPage, public LevCoreSpeedSystemInformation { 21 | public: 22 | explicit LevBaseSpeedSystemInformation(AntRxDataResponse& dp); 23 | }; 24 | 25 | class LevBaseSpeedSystemInformationMsg : public LevBaseMainDataPageMsg, public LevCoreSpeedSystemInformation { 26 | public: 27 | LevBaseSpeedSystemInformationMsg(uint8_t dataPageNumber); 28 | void setCurrentRegenerativeLevel(uint8_t level); 29 | void setCurrentAssistLevel(uint8_t level); 30 | void setSystemState(uint8_t state); 31 | void setCurrentFrontGear(uint8_t gear); 32 | void setCurrentRearGear(uint8_t gear); 33 | void setManualAutoState(uint8_t state); 34 | void setGearExist(uint8_t exists); 35 | void setSpeed(uint16_t speed); // in 1/10 km/h 36 | }; 37 | 38 | #endif // ANTPLUS_LEVBASESPEEDSYSTEMINFORMATION_h 39 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_MultiComponentSystemManufacturersInformation.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_MULTICOMPONENTSYSTEMMANUFACTURERSINFORMATION_h 2 | #define ANTPLUS_MULTICOMPONENTSYSTEMMANUFACTURERSINFORMATION_h 3 | 4 | #include 5 | #include 6 | 7 | // Common page 78 8 | 9 | template 10 | class BaseMultiComponentSystemManufacturersInformation : virtual public CoreDataPage { 11 | public: 12 | BaseMultiComponentSystemManufacturersInformation(); 13 | uint8_t getNumberOfComponents(); 14 | uint8_t getComponentIdentifier(); 15 | uint8_t getHWRevision(); 16 | uint16_t getManufacturerId(); 17 | uint16_t getModelNumber(); 18 | }; 19 | 20 | class MultiComponentSystemManufacturersInformation : public BaseDataPage, public BaseMultiComponentSystemManufacturersInformation { 21 | public: 22 | explicit MultiComponentSystemManufacturersInformation(AntRxDataResponse& dp); 23 | }; 24 | 25 | class MultiComponentSystemManufacturersInformationMsg : public BaseDataPageMsg, public BaseMultiComponentSystemManufacturersInformation { 26 | public: 27 | MultiComponentSystemManufacturersInformationMsg(); 28 | void setNumberOfComponents(uint8_t count); 29 | void setComponentIdentifier(uint8_t identifier); 30 | void setHWRevision(uint8_t rev); 31 | void setManufacturerId(uint16_t id); 32 | void setModelNumber(uint16_t model); 33 | private: 34 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 35 | }; 36 | 37 | #endif // ANTPLUS_MULTICOMPONENTSYSTEMMANUFACTURERSINFORMATION_h 38 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_RequestDataPage.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_REQUESTDATAPAGE_h 2 | #define ANTPLUS_REQUESTDATAPAGE_h 3 | 4 | #include 5 | #include 6 | 7 | // Common Page 70 8 | 9 | template 10 | class BaseRequestDataPage : virtual public CoreDataPage { 11 | public: 12 | BaseRequestDataPage(); 13 | uint16_t getSlaveSerialNumber(); 14 | uint8_t getDescriptorByte1(); 15 | uint8_t getDescriptorByte2(); 16 | uint8_t getRequestedTransmissionResponseCount(); 17 | uint8_t getRequestedTransmissionUseAcknowledged(); 18 | uint8_t transmitTillAcknowledged(); 19 | uint8_t getRequestedPageNumber(); 20 | uint8_t getCommandType(); 21 | }; 22 | 23 | class RequestDataPage : public BaseDataPage, public BaseRequestDataPage { 24 | public: 25 | explicit RequestDataPage(AntRxDataResponse& dp); 26 | }; 27 | 28 | class RequestDataPageMsg : public BaseDataPageMsg, public BaseRequestDataPage { 29 | public: 30 | RequestDataPageMsg(); 31 | void setSlaveSerialNumber(uint16_t serialNumber); 32 | void setDescriptorByte1(uint8_t descriptorByte); 33 | void setDescriptorByte2(uint8_t descriptorByte); 34 | void setRequestedTransmissionResponseCount(uint8_t count); 35 | void setRequestedTransmissionUseAcknowledged(uint8_t useAcknowledged); 36 | void setRequestedPageNumber(uint8_t pageNumber); 37 | void setCommandType(uint8_t commandType); 38 | private: 39 | uint8_t _buffer[MESSAGE_SIZE] = {0}; 40 | }; 41 | 42 | #endif // ANTPLUS_REQUESTDATAPAGE_h 43 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateManufacturerInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define MANUFACTUREREIDLSB_BYTE 1 5 | #define SERIALNUMBER_LSB_BYTE 2 6 | #define SERIALNUMBER_MSB_BYTE 3 7 | 8 | template 9 | HeartRateBaseManufacturerInformation::HeartRateBaseManufacturerInformation() : 10 | CoreDataPage() {} 11 | 12 | template 13 | uint8_t HeartRateBaseManufacturerInformation::getManufacturerIdLsb() { 14 | return this->get8BitValue(MANUFACTUREREIDLSB_BYTE); 15 | } 16 | 17 | template 18 | uint16_t HeartRateBaseManufacturerInformation::getSerialNumber() { 19 | return this->get16BitValue(SERIALNUMBER_LSB_BYTE, SERIALNUMBER_MSB_BYTE); 20 | } 21 | 22 | template class HeartRateBaseManufacturerInformation; 23 | template class HeartRateBaseManufacturerInformation; 24 | 25 | HeartRateManufacturerInformation::HeartRateManufacturerInformation(AntRxDataResponse& dp) : 26 | HeartRateBaseMainDataPage(dp), 27 | HeartRateBaseManufacturerInformation() {} 28 | 29 | HeartRateManufacturerInformationMsg::HeartRateManufacturerInformationMsg() : 30 | HeartRateBaseMainDataPageMsg(HEARTRATE_MANUFACTURERINFORMATION_NUMBER), 31 | HeartRateBaseManufacturerInformation() {} 32 | 33 | void HeartRateManufacturerInformationMsg::setManufacturerIdLsb(uint8_t id) { 34 | set8BitValue(id, MANUFACTUREREIDLSB_BYTE); 35 | } 36 | 37 | void HeartRateManufacturerInformationMsg::setSerialNumber(uint16_t serialNumber) { 38 | set16BitValue(serialNumber, SERIALNUMBER_LSB_BYTE, SERIALNUMBER_MSB_BYTE); 39 | } 40 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecSpecificTrainerData.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_FECTRAINERDATA_h 2 | #define ANTPLUS_FECTRAINERDATA_h 3 | 4 | #include 5 | 6 | template 7 | class FecBaseSpecificTrainerData : virtual public CoreDataPage { 8 | public: 9 | FecBaseSpecificTrainerData(); 10 | uint8_t getUpdateEventCount(); 11 | uint8_t getInstantaneousCadence(); 12 | uint16_t getAccumulatedPower(); 13 | uint16_t getInstantaneousPower(); 14 | uint8_t getBicyclePowerCalibration(); 15 | uint8_t getResistanceCalibration(); 16 | uint8_t getUserConfiguration(); 17 | uint8_t getTargetPowerLimits(); 18 | uint8_t getFeState(); 19 | uint8_t getLapToggleBit(); 20 | }; 21 | 22 | class FecSpecificTrainerData : public BaseDataPage, public FecBaseSpecificTrainerData { 23 | public: 24 | explicit FecSpecificTrainerData(AntRxDataResponse& dp); 25 | }; 26 | 27 | class FecSpecificTrainerDataMsg : public BaseDataPageMsg, public FecBaseSpecificTrainerData { 28 | public: 29 | FecSpecificTrainerDataMsg(); 30 | void setUpdateEventCount(uint8_t eventCount); 31 | void setInstantaneousCadence(uint8_t cadence); 32 | void setAccumulatedPower(uint16_t accPower); 33 | void setInstantaneousPower(uint16_t intPower); 34 | void setBicyclePowerCalibration(uint8_t powerCalibration); 35 | void setResistanceCalibration(uint8_t resistanceCalibration); 36 | void setUserConfiguration(uint8_t userConfiguration); 37 | void setTargetPowerLimits(uint8_t targetPower); 38 | void setFeState(uint8_t feState); 39 | void setLapToggleBit(uint8_t lapToggle); 40 | }; 41 | 42 | #endif // ANTPLUS_FECTRAINERDATA_h 43 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevBaseSpeedDistanceInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define ODOMETER_LSB_BYTE 1 5 | #define ODOMETER_MSB_BYTE 3 6 | #define LEVSPEED_LSB_BYTE 6 7 | #define LEVSPEED_MSB_BYTE 7 8 | #define LEVSPEED_MASK 0x0FFF 9 | 10 | /* Speed and Distance */ 11 | template 12 | LevCoreSpeedDistanceInformation::LevCoreSpeedDistanceInformation() : 13 | CoreDataPage() {} 14 | 15 | template 16 | uint32_t LevCoreSpeedDistanceInformation::getOdometer() { // in km 17 | return this->get24BitValue(ODOMETER_LSB_BYTE, ODOMETER_MSB_BYTE); 18 | } 19 | 20 | template 21 | uint16_t LevCoreSpeedDistanceInformation::getLevSpeed() { // in 1/10 km/h 22 | return this->get16BitValue(LEVSPEED_LSB_BYTE, LEVSPEED_MSB_BYTE, 23 | LEVSPEED_MASK); 24 | } 25 | 26 | template class LevCoreSpeedDistanceInformation; 27 | template class LevCoreSpeedDistanceInformation; 28 | 29 | LevBaseSpeedDistanceInformation::LevBaseSpeedDistanceInformation(AntRxDataResponse& dp) : 30 | LevBaseMainDataPage(dp), 31 | LevCoreSpeedDistanceInformation() {} 32 | 33 | LevBaseSpeedDistanceInformationMsg::LevBaseSpeedDistanceInformationMsg(uint8_t dataPageNumber) : 34 | LevBaseMainDataPageMsg(dataPageNumber), 35 | LevCoreSpeedDistanceInformation() {} 36 | 37 | void LevBaseSpeedDistanceInformationMsg::setOdometer(uint32_t odometer) { 38 | set24BitValue(odometer, ODOMETER_LSB_BYTE, ODOMETER_MSB_BYTE); 39 | } 40 | 41 | void LevBaseSpeedDistanceInformationMsg::setLevSpeed(uint16_t speed) { 42 | set16BitValue(speed, LEVSPEED_LSB_BYTE, LEVSPEED_MSB_BYTE, LEVSPEED_MASK); 43 | } 44 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecTrackResistance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define RESERVED_LSB_BYTE 1 5 | #define RESERVED_MSB_BYTE 4 6 | #define RESERVED_VALUE 0xFFFFFFFF 7 | #define GRADE_LSB_BYTE 5 8 | #define GRADE_MSB_BYTE 6 9 | #define COEFFICIENTOFROLLINGRESISTANCE_BYTE 7 10 | 11 | template 12 | FecBaseTrackResistance::FecBaseTrackResistance() : 13 | CoreDataPage() {} 14 | 15 | template 16 | uint16_t FecBaseTrackResistance::getGrade() { 17 | return this->get16BitValue(GRADE_LSB_BYTE, GRADE_MSB_BYTE); 18 | } 19 | 20 | template 21 | uint8_t FecBaseTrackResistance::getCoefficientOfRollingResistance() { 22 | return this->get8BitValue(COEFFICIENTOFROLLINGRESISTANCE_BYTE); 23 | } 24 | 25 | template class FecBaseTrackResistance; 26 | template class FecBaseTrackResistance; 27 | 28 | FecTrackResistance::FecTrackResistance(AntRxDataResponse& dp) : 29 | FecBaseMainDataPage(dp), 30 | FecBaseTrackResistance() {} 31 | 32 | FecTrackResistanceMsg::FecTrackResistanceMsg() : 33 | FecBaseMainDataPageMsg(ANTPLUS_FEC_DATAPAGE_TRACKRESISTANCE_NUMBER), 34 | FecBaseTrackResistance() { 35 | set32BitValue(RESERVED_VALUE, RESERVED_LSB_BYTE, RESERVED_MSB_BYTE); 36 | setTargetGrade(ANTPLUS_FEC_DATAPAGE_TRACKRESISTANCE_GRADE_INVALID); 37 | setCoefficientOfRollingResistance(ANTPLUS_FEC_DATAPAGE_TRACKRESISTANCE_COEFFICIENTOFROLLINGRESISTANCE_INVALID); 38 | } 39 | 40 | void FecTrackResistanceMsg::setTargetGrade(uint16_t TargetGrade) { 41 | set16BitValue(TargetGrade, GRADE_LSB_BYTE, GRADE_MSB_BYTE); 42 | } 43 | 44 | void FecTrackResistanceMsg::setCoefficientOfRollingResistance(uint8_t coefficient) { 45 | set8BitValue(coefficient, COEFFICIENTOFROLLINGRESISTANCE_BYTE); 46 | } 47 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevDisplayData.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_LEVDISPLAYDATAMSG_h 2 | #define ANTPLUS_LEVDISPLAYDATAMSG_h 3 | 4 | #include 5 | 6 | template 7 | class LevBaseDisplayData : virtual public CoreDataPage { 8 | public: 9 | LevBaseDisplayData(); 10 | uint16_t getWheelCircumference(); 11 | uint8_t getCurrentAssistLevel(); 12 | uint8_t getCurrentRegenerativeLevel(); 13 | uint8_t getCurrentRearGear(); 14 | uint8_t getCurrentFrontGear(); 15 | uint8_t getCurrentLightMode(); 16 | bool getDisplayCommandTurnSignalRight(); 17 | bool getDisplayCommandTurnSignalLeft(); 18 | bool getDisplayCommandLightHighBeam(); 19 | bool getDisplayCommandLightOnOff(); 20 | uint16_t getManufacturerID(); 21 | }; 22 | 23 | class LevDisplayData : public LevBaseMainDataPage, public LevBaseDisplayData { 24 | public: 25 | explicit LevDisplayData(AntRxDataResponse& dp); 26 | }; 27 | 28 | class LevDisplayDataMsg : public LevBaseMainDataPageMsg, public LevBaseDisplayData { 29 | public: 30 | LevDisplayDataMsg(); 31 | void setWheelCircumference(uint16_t circumference); 32 | /** 33 | * TODO add special handler to set special case for TravelMode not supported/not set 34 | * requires changing reserved bits 35 | */ 36 | void setCurrentAssistLevel(uint8_t level); 37 | void setCurrentRegenerativeLevel(uint8_t level); 38 | void setCurrentRearGear(uint8_t gear); 39 | void setCurrentFrontGear(uint8_t gear); 40 | void setDisplayCommandTurnSignalRight(bool rightSignal); 41 | void setDisplayCommandTurnSignalLeft(bool leftSignal); 42 | void setDisplayCommandLightHighBeam(bool highBeam); 43 | void setDisplayCommandLightOnOff(bool onOff); 44 | void setManufacturerID(uint16_t id); 45 | }; 46 | 47 | #endif // ANTPLUS_LEVDISPLAYDATAMSG_h 48 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateProductInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define HARDWAREVERSION_BYTE 1 5 | #define SOFTWAREVERSION_BYTE 2 6 | #define MODELNUMBER_BYTE 3 7 | 8 | template 9 | HeartRateBaseProductInformation::HeartRateBaseProductInformation() : 10 | CoreDataPage() {} 11 | 12 | template 13 | uint8_t HeartRateBaseProductInformation::getHardwareVersion() { 14 | return this->get8BitValue(HARDWAREVERSION_BYTE); 15 | } 16 | 17 | template 18 | uint8_t HeartRateBaseProductInformation::getSoftwareVersion() { 19 | return this->get8BitValue(SOFTWAREVERSION_BYTE); 20 | } 21 | 22 | template 23 | uint8_t HeartRateBaseProductInformation::getModelNumber() { 24 | return this->get8BitValue(MODELNUMBER_BYTE); 25 | } 26 | 27 | template class HeartRateBaseProductInformation; 28 | template class HeartRateBaseProductInformation; 29 | 30 | HeartRateProductInformation::HeartRateProductInformation(AntRxDataResponse& dp) : 31 | HeartRateBaseMainDataPage(dp), 32 | HeartRateBaseProductInformation() {} 33 | 34 | HeartRateProductInformationMsg::HeartRateProductInformationMsg() : 35 | HeartRateBaseMainDataPageMsg(HEARTRATE_PRODUCTINFORMATION_NUMBER), 36 | HeartRateBaseProductInformation() {} 37 | 38 | void HeartRateProductInformationMsg::setHardwareVersion(uint8_t hwVersion) { 39 | this->set8BitValue(hwVersion, HARDWAREVERSION_BYTE); 40 | } 41 | 42 | void HeartRateProductInformationMsg::setSoftwareVersion(uint8_t swVersion) { 43 | this->set8BitValue(swVersion, SOFTWAREVERSION_BYTE); 44 | } 45 | 46 | void HeartRateProductInformationMsg::setModelNumber(uint8_t modelNumber) { 47 | this->set8BitValue(modelNumber, MODELNUMBER_BYTE); 48 | } 49 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/DataPages/ANTPLUS_ShiftingShiftSystemStatus.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_SHIFTINGSHIFTSYSTEMSTATUS_h 2 | #define ANTPLUS_SHIFTINGSHIFTSYSTEMSTATUS_h 3 | 4 | #include 5 | 6 | template 7 | class ShiftingBaseShiftSystemStatus : virtual public CoreDataPage { 8 | public: 9 | ShiftingBaseShiftSystemStatus(); 10 | uint8_t getEventCount(); 11 | uint8_t getCurrentGearRear(); 12 | uint8_t getCurrentGearFront(); 13 | uint8_t getTotalNumbersGearRear(); 14 | uint8_t getTotalNumbersGearFront(); 15 | uint8_t getInvalidInboardShiftCountRear(); 16 | uint8_t getInvalidOutboardShiftCountRear(); 17 | uint8_t getInvalidInboardShiftCountFront(); 18 | uint8_t getInvalidOutboardShiftCountFront(); 19 | uint8_t getShiftFailureCountRear(); 20 | uint8_t getShiftFailureCountFront(); 21 | }; 22 | 23 | class ShiftingShiftSystemStatus : public ShiftingBaseMainDataPage, public ShiftingBaseShiftSystemStatus { 24 | public: 25 | explicit ShiftingShiftSystemStatus(AntRxDataResponse& dp); 26 | }; 27 | 28 | class ShiftingShiftSystemStatusMsg : public ShiftingBaseMainDataPageMsg, public ShiftingBaseShiftSystemStatus { 29 | public: 30 | ShiftingShiftSystemStatusMsg(); 31 | void setEventCount(uint8_t n); 32 | void setCurrentGearRear(uint8_t cgr); 33 | void setCurrentGearFront(uint8_t cgf); 34 | void setTotalNumbersGearRear(uint8_t tgr); 35 | void setTotalNumbersGearFront(uint8_t tgf); 36 | void setInvalidInboardShiftCountRear(uint8_t isr); 37 | void setInvalidOutboardShiftCountRear(uint8_t osr); 38 | void setInvalidInboardShiftCountFront(uint8_t isf); 39 | void setInvalidOutboardShiftCountFront(uint8_t osf); 40 | void setShiftFailureCountRear(uint8_t sfr); 41 | void setShiftFailureCountFront(uint8_t sff); 42 | }; 43 | 44 | #endif // ANTPLUS_SHIFTINGSHIFTSYSTEMSTATUS_h 45 | -------------------------------------------------------------------------------- /src/Profiles/Environment/DataPages/ANTPLUS_EnvironmentGeneralInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define TRANSMISSIONINFO_BYTE 3 5 | #define TRANSMISSIONINFO_LOCALTIME_MASK 0x30 6 | #define TRANSMISSIONINFO_UTCTIME_MASK 0x0C 7 | #define TRANSMISSIONINFO_DEFAULTTRANSMISSIONRATE_MASK 0x03 8 | #define TRANSMISSIONINFO_LOCALTIME_SHIFT 4 9 | #define TRANSMISSIONINFO_UTCTIME_SHIFT 2 10 | #define SUPPORTEDPAGES_LSB_BYTE 4 11 | #define SUPPORTEDPAGES_MSB_BYTE 7 12 | 13 | template 14 | EnvironmentBaseGeneralInformation::EnvironmentBaseGeneralInformation() : 15 | CoreDataPage() {} 16 | 17 | template 18 | uint8_t EnvironmentBaseGeneralInformation::getTransmissionInfoLocalTime() { 19 | return this->get8BitValue(TRANSMISSIONINFO_BYTE, 20 | TRANSMISSIONINFO_LOCALTIME_MASK, TRANSMISSIONINFO_LOCALTIME_SHIFT); 21 | } 22 | 23 | template 24 | uint8_t EnvironmentBaseGeneralInformation::getTransmissionInfoUtcTime() { 25 | return this->get8BitValue(TRANSMISSIONINFO_BYTE, 26 | TRANSMISSIONINFO_UTCTIME_MASK, TRANSMISSIONINFO_UTCTIME_SHIFT); 27 | } 28 | 29 | template 30 | uint8_t EnvironmentBaseGeneralInformation::getTransmissionInfoDefaultTransmissionRate() { 31 | return this->get8BitValue(TRANSMISSIONINFO_BYTE, 32 | TRANSMISSIONINFO_DEFAULTTRANSMISSIONRATE_MASK); 33 | } 34 | 35 | template 36 | uint32_t EnvironmentBaseGeneralInformation::getSupportedPages() { 37 | return this->get32BitValue(SUPPORTEDPAGES_LSB_BYTE, 38 | SUPPORTEDPAGES_MSB_BYTE); 39 | } 40 | 41 | template class EnvironmentBaseGeneralInformation; 42 | template class EnvironmentBaseGeneralInformation; 43 | 44 | EnvironmentGeneralInformation::EnvironmentGeneralInformation(AntRxDataResponse& dp) : 45 | EnvironmentBaseDataPage(dp), 46 | EnvironmentBaseGeneralInformation() {} 47 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/DataPages/ANTPLUS_MuscleOxygenCommands.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define COMMANDID_BYTE 1 5 | #define RESERVED_BYTE 2 6 | #define LOCALTIMEOFFSET_BYTE 3 7 | #define CURRENTTIMETIMESTAMP_LSB_BYTE 4 8 | #define CURRENTTIMETIMESTAMP_MSB_BYTE 7 9 | 10 | #define RESERVED_VALUE 0xFF 11 | 12 | template 13 | MuscleOxygenBaseCommands::MuscleOxygenBaseCommands() : CoreDataPage() {} 14 | 15 | template 16 | uint8_t MuscleOxygenBaseCommands::getCommandId() { 17 | return this->get8BitValue(COMMANDID_BYTE); 18 | } 19 | 20 | template 21 | uint8_t MuscleOxygenBaseCommands::getLocalTimeOffset() { 22 | return this->get8BitValue(LOCALTIMEOFFSET_BYTE); 23 | } 24 | 25 | template 26 | uint32_t MuscleOxygenBaseCommands::getCurrentTimestamp() { 27 | return this->get32BitValue(CURRENTTIMETIMESTAMP_LSB_BYTE, 28 | CURRENTTIMETIMESTAMP_MSB_BYTE); 29 | } 30 | 31 | template class MuscleOxygenBaseCommands; 32 | template class MuscleOxygenBaseCommands; 33 | 34 | MuscleOxygenCommands::MuscleOxygenCommands(AntRxDataResponse& dp) : 35 | MuscleOxygenBaseMainDataPage(dp), 36 | MuscleOxygenBaseCommands() {} 37 | 38 | MuscleOxygenCommandsMsg::MuscleOxygenCommandsMsg() : 39 | MuscleOxygenBaseMainDataPageMsg(ANTPLUS_MUSCLEOXYGEN_DATAPAGE_COMMANDS_NUMBER), 40 | MuscleOxygenBaseCommands() { 41 | set8BitValue(RESERVED_VALUE, RESERVED_BYTE); 42 | } 43 | 44 | void MuscleOxygenCommandsMsg::setCommandId(uint8_t id) { 45 | set8BitValue(id, COMMANDID_BYTE); 46 | } 47 | 48 | void MuscleOxygenCommandsMsg::setLocalTimeOffset(uint8_t offset) { 49 | set8BitValue(offset, LOCALTIMEOFFSET_BYTE); 50 | } 51 | 52 | void MuscleOxygenCommandsMsg::setCurrentTimestamp(uint32_t timestamp) { 53 | set32BitValue(timestamp, CURRENTTIMETIMESTAMP_LSB_BYTE, 54 | CURRENTTIMETIMESTAMP_MSB_BYTE); 55 | } 56 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRatePreviousHeartBeat.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define MANUFACTURERSPECIFIC_BYTE 1 6 | #define PREVIOUSHEARTBEATEVENTTIME_LSB_BYTE 2 7 | #define PREVIOUSHEARTBEATEVENTTIME_MSB_BYTE 3 8 | 9 | template 10 | HeartRateBasePreviousHeartBeat::HeartRateBasePreviousHeartBeat() : 11 | CoreDataPage() {} 12 | 13 | template 14 | uint8_t HeartRateBasePreviousHeartBeat::getManufacturerSpecific() { 15 | return this->get8BitValue(MANUFACTURERSPECIFIC_BYTE); 16 | } 17 | 18 | template 19 | uint16_t HeartRateBasePreviousHeartBeat::getPreviousHeartBeatEventTime() { 20 | return this->get16BitValue( 21 | PREVIOUSHEARTBEATEVENTTIME_LSB_BYTE, 22 | PREVIOUSHEARTBEATEVENTTIME_MSB_BYTE); 23 | } 24 | 25 | template class HeartRateBasePreviousHeartBeat; 26 | template class HeartRateBasePreviousHeartBeat; 27 | 28 | HeartRatePreviousHeartBeat::HeartRatePreviousHeartBeat(AntRxDataResponse& dp) : 29 | HeartRateBaseMainDataPage(dp), 30 | HeartRateBasePreviousHeartBeat() {} 31 | 32 | // TODO add isValid method to manufactueres byte 33 | HeartRatePreviousHeartBeatMsg::HeartRatePreviousHeartBeatMsg() : 34 | HeartRateBaseMainDataPageMsg(HEARTRATE_PREVIOUSHEARTBEAT_NUMBER), 35 | HeartRateBasePreviousHeartBeat() { 36 | setManufacturerSpecific( 37 | ANTPLUS_HEARTRATE_DATAPAGE_PREVIOUSHEARTBEAT_MANUFACTURERSPECIFIC_INVALID); 38 | } 39 | 40 | void HeartRatePreviousHeartBeatMsg::setManufacturerSpecific(uint8_t specificByte) { 41 | set8BitValue(specificByte, MANUFACTURERSPECIFIC_BYTE); 42 | } 43 | 44 | void HeartRatePreviousHeartBeatMsg::setPreviousHeartBeatEventTime(uint16_t eventTime) { 45 | set16BitValue(eventTime, 46 | PREVIOUSHEARTBEATEVENTTIME_LSB_BYTE, 47 | PREVIOUSHEARTBEATEVENTTIME_MSB_BYTE); 48 | } 49 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/ANTPLUS_BicyclePowerDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BICYCLEPOWERPROFILEDEFINES_h 2 | #define ANTPLUS_BICYCLEPOWERPROFILEDEFINES_h 3 | 4 | #define ANTPLUS_BICYCLEPOWER_DEVICETYPE 11 5 | 6 | /* Sensor Types */ 7 | #define ANTPLUS_BICYCLEPOWER_FLAGS_SENSORTYPE_POWERONLY 0 8 | #define ANTPLUS_BICYCLEPOWER_FLAGS_SENSORTYPE_TORQUEWHEEL 1 9 | #define ANTPLUS_BICYCLEPOWER_FLAGS_SENSORTYPE_TORQUECRANK 2 10 | #define ANTPLUS_BICYCLEPOWER_FLAGS_SENSORTYPE_CTF 3 11 | 12 | /* DataPage Defines */ 13 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_GENERALCALIBRATION_NUMBER 0x01 14 | 15 | 16 | /* Standard Power Only */ 17 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDPOWERONLY_NUMBER 0x10 18 | 19 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDPOWERONLY_PEDALDIFFERENTIATION_RIGHT 1 20 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDPOWERONLY_PEDALPOWER_NOTUSED 0x7F 21 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDPOWERONLY_INSTANTANEOUSCADENCE_INVALID 0xFF 22 | 23 | 24 | /* Standard Wheel Torque */ 25 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDWHEELTORQUE_NUMBER 0x11 26 | 27 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDWHEELTORQUE_INSTANTANEOUSCADENCE_INVALID 0xFF 28 | 29 | 30 | /* Standard Crank Torque */ 31 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDCRANKTORQUE_NUMBER 0x12 32 | 33 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDCRANKTORQUE_INSTANTANEOUSCADENCE_INVALID 0xFF 34 | 35 | 36 | /* Torqyue and Pedal Smoothness */ 37 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_TORQUEEFFECTIVENESSANDPEDALSMOOTHNESS_NUMBER 0x13 38 | 39 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_TORQUEEFFECTIVENESSANDPEDALSMOOTHNESS_TORQUEEFFECTIVENESS_INVALID 0xFF 40 | 41 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_TORQUEEFFECTIVENESSANDPEDALSMOOTHNESS_PEDALSMOOTHNESS_INVALID 0xFF 42 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_TORQUEEFFECTIVENESSANDPEDALSMOOTHNESS_RIGHTPEDALSMOOTHNESS_COMBINED 0xFE 43 | 44 | /* Crank Torque Frequency */ 45 | #define ANTPLUS_BICYCLEPOWER_DATAPAGES_CRANKTORQUEFREQUENCY_NUMBER 0x20 46 | 47 | 48 | #endif // ANTPLUS_BICYCLEPOWERPROFILEDEFINES_h 49 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "ANT.h" 4 | 5 | template 6 | BaseDataPage::BaseDataPage(AntRxDataResponse& msg) : CoreDataPage() { 7 | this->setFrameData(msg.getFrameData()); 8 | this->setMsgId(msg.getMsgId()); 9 | this->setAvailable(msg.isAvailable()); 10 | this->setChecksum(msg.getChecksum()); 11 | this->setErrorCode(msg.getErrorCode()); 12 | this->setLength(msg.getLength()); 13 | } 14 | 15 | template 16 | uint8_t BaseDataPage::get8BitValue(uint8_t byte, uint8_t mask, uint8_t shift) { 17 | uint8_t temp = this->getData(byte); 18 | temp &= mask; 19 | return temp >> shift; 20 | } 21 | 22 | template 23 | uint16_t BaseDataPage::get16BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint16_t mask, uint8_t shift) { 24 | uint16_t temp = this->getData(msb_byte); 25 | temp <<= BITS_IN_BYTE; 26 | temp |= this->getData(lsb_byte); 27 | temp &= mask; 28 | return temp >> shift; 29 | } 30 | 31 | template 32 | uint32_t BaseDataPage::get24BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask, uint8_t shift) { 33 | int8_t step = this->getByteStepDirection(msb_byte, lsb_byte); 34 | uint32_t temp = this->getData(msb_byte); 35 | temp <<= BITS_IN_BYTE; 36 | temp |= this->getData(msb_byte + step); 37 | temp <<= BITS_IN_BYTE; 38 | temp |= this->getData(lsb_byte); 39 | temp &= mask; 40 | return temp >> shift; 41 | } 42 | 43 | template 44 | uint32_t BaseDataPage::get32BitValue(uint8_t lsb_byte, uint8_t msb_byte, uint32_t mask, uint8_t shift) { 45 | int8_t step = this->getByteStepDirection(msb_byte, lsb_byte); 46 | uint32_t temp = this->getData(msb_byte); 47 | temp <<= BITS_IN_BYTE; 48 | temp |= this->getData(msb_byte + step); 49 | temp <<= BITS_IN_BYTE; 50 | temp |= this->getData(msb_byte + (step * 2)); 51 | temp <<= BITS_IN_BYTE; 52 | temp |= this->getData(lsb_byte); 53 | temp &= mask; 54 | return temp >> shift; 55 | } 56 | 57 | template class BaseDataPage; 58 | template class BaseDataPage; 59 | -------------------------------------------------------------------------------- /src/Profiles/Environment/Profiles/ANTPLUS_ProfileEnvironmentDisplay.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEENVIRONMENTDISPLAY_h 2 | #define ANTPLUS_PROFILEENVIRONMENTDISPLAY_h 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class ProfileEnvironmentDisplay : public BaseSlaveProfile { 9 | public: 10 | ProfileEnvironmentDisplay(); 11 | explicit ProfileEnvironmentDisplay(uint16_t deviceNumber); 12 | explicit ProfileEnvironmentDisplay(uint16_t deviceNumber, uint8_t transmissionType); 13 | void onEnvironmentGeneralInformation(void (*func)(EnvironmentGeneralInformation&, uintptr_t), uintptr_t data = 0) { _onEnvironmentGeneralInformation.set(func, data); } 14 | void onEnvironmentTemperature(void (*func)(EnvironmentTemperature&, uintptr_t), uintptr_t data = 0) { _onEnvironmentTemperature.set(func, data); } 15 | void onManufacturersInformation(void (*func)(ManufacturersInformation&, uintptr_t), uintptr_t data = 0) { _onManufacturersInformation.set(func, data); } 16 | void onProductInformation(void (*func)(ProductInformation&, uintptr_t), uintptr_t data = 0) { _onProductInformation.set(func, data); } 17 | 18 | private: 19 | void setChannelConfig(); 20 | void onBroadcastData(BroadcastData& msg) override; 21 | void onAcknowledgedData(AcknowledgedData& msg) override; 22 | 23 | bool handleDataPage(EnvironmentBaseDataPage& dp); 24 | 25 | bool handleGeneralInformation(EnvironmentBaseDataPage& dataPage); 26 | bool handleTemperature(EnvironmentBaseDataPage& dataPage); 27 | bool handleManufacturersInformation(EnvironmentBaseDataPage& dataPage); 28 | bool handleProductInformation(EnvironmentBaseDataPage& dataPage); 29 | AntCallback _onEnvironmentGeneralInformation = { .func = NULL }; 30 | AntCallback _onEnvironmentTemperature = { .func = NULL }; 31 | AntCallback _onManufacturersInformation = { .func = NULL }; 32 | AntCallback _onProductInformation = { .func = NULL }; 33 | }; 34 | 35 | #endif // ANTPLUS_PROFILEENVIRONMENTDISPLAY_h 36 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ProductInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define RESERVED_BYTE 1 6 | #define RESERVED_VALUE 0xFF 7 | #define SWREVISIONSUPPLEMENTAL_BYTE 2 8 | #define SWREVISIONMAIN_BYTE 3 9 | #define SERIALNUMBER_LSB_BYTE 4 10 | #define SERIALNUMBER_MSB_BYTE 7 11 | 12 | template 13 | BaseProductInformation::BaseProductInformation() : CoreDataPage() {} 14 | 15 | template 16 | uint8_t BaseProductInformation::getSWRevisionSupplemental() { 17 | return this->get8BitValue(SWREVISIONSUPPLEMENTAL_BYTE); 18 | } 19 | 20 | template 21 | uint8_t BaseProductInformation::getSWRevisionMain() { 22 | return this->get8BitValue(SWREVISIONMAIN_BYTE); 23 | } 24 | 25 | template 26 | uint32_t BaseProductInformation::getSerialNumber() { 27 | return this->get32BitValue(SERIALNUMBER_LSB_BYTE, SERIALNUMBER_MSB_BYTE); 28 | } 29 | 30 | template class BaseProductInformation; 31 | template class BaseProductInformation; 32 | 33 | ProductInformation::ProductInformation(AntRxDataResponse& dp) : 34 | BaseDataPage(dp), 35 | BaseProductInformation() {} 36 | 37 | ProductInformationMsg::ProductInformationMsg() : 38 | BaseDataPageMsg(), 39 | BaseProductInformation() { 40 | setDataBuffer(_buffer); 41 | set8BitValue(ANTPLUS_COMMON_DATAPAGE_PRODUCTINFORMATION_NUMBER, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 42 | set8BitValue(RESERVED_VALUE, RESERVED_BYTE); 43 | set8BitValue(ANTPLUS_COMMON_DATAPAGE_PRODUCTINFORMATION_SWREVISIONSUPPLEMENTAL_INVALID, SWREVISIONSUPPLEMENTAL_BYTE); 44 | } 45 | 46 | void ProductInformationMsg::setSWRevisionSupplemental(uint8_t revision) { 47 | set8BitValue(revision, SWREVISIONSUPPLEMENTAL_BYTE); 48 | } 49 | 50 | void ProductInformationMsg::setSWRevisionMain(uint8_t revision) { 51 | set8BitValue(revision, SWREVISIONMAIN_BYTE); 52 | } 53 | 54 | void ProductInformationMsg::setSerialNumber(uint32_t serialNumber) { 55 | set32BitValue(serialNumber, SERIALNUMBER_LSB_BYTE, SERIALNUMBER_MSB_BYTE); 56 | } 57 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerCrankTorqueFrequency.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define SLOPE_MSB_BYTE 2 5 | #define SLOPE_LSB_BYTE 3 6 | #define TIMESTAMP_MSB_BYTE 4 7 | #define TIMESTAMP_LSB_BYTE 5 8 | #define TORQUETICKSTAMP_MSB_BYTE 6 9 | #define TORQUETICKSTAMP_LSB_BYTE 7 10 | 11 | template 12 | BicyclePowerBaseCrankTorqueFrequency::BicyclePowerBaseCrankTorqueFrequency() : 13 | CoreDataPage() {} 14 | 15 | template 16 | uint16_t BicyclePowerBaseCrankTorqueFrequency::getSlope() { 17 | return this->get16BitValue(SLOPE_LSB_BYTE, SLOPE_MSB_BYTE); 18 | } 19 | 20 | template 21 | uint16_t BicyclePowerBaseCrankTorqueFrequency::getTimeStamp() { 22 | return this->get16BitValue(TIMESTAMP_LSB_BYTE, TIMESTAMP_MSB_BYTE); 23 | } 24 | 25 | template 26 | uint16_t BicyclePowerBaseCrankTorqueFrequency::getTorqueTicksStamp() { 27 | return this->get16BitValue(TORQUETICKSTAMP_LSB_BYTE, 28 | TORQUETICKSTAMP_MSB_BYTE); 29 | } 30 | 31 | template class BicyclePowerBaseCrankTorqueFrequency; 32 | template class BicyclePowerBaseCrankTorqueFrequency; 33 | 34 | BicyclePowerCrankTorqueFrequency::BicyclePowerCrankTorqueFrequency(AntRxDataResponse& dp) : 35 | BicyclePowerBaseMainDataPage(dp), 36 | BicyclePowerBaseCrankTorqueFrequency() {} 37 | 38 | BicyclePowerCrankTorqueFrequencyMsg::BicyclePowerCrankTorqueFrequencyMsg() : 39 | BicyclePowerBaseMainDataPageMsg(ANTPLUS_BICYCLEPOWER_DATAPAGES_CRANKTORQUEFREQUENCY_NUMBER), 40 | BicyclePowerBaseCrankTorqueFrequency() {} 41 | 42 | void BicyclePowerCrankTorqueFrequencyMsg::setSlope(uint16_t slope) { 43 | set16BitValue(slope, SLOPE_LSB_BYTE, SLOPE_MSB_BYTE); 44 | } 45 | 46 | void BicyclePowerCrankTorqueFrequencyMsg::setTimeStamp(uint16_t timestamp) { 47 | set16BitValue(timestamp, TIMESTAMP_LSB_BYTE, TIMESTAMP_MSB_BYTE); 48 | } 49 | 50 | void BicyclePowerCrankTorqueFrequencyMsg::setTorqueTicksStamp(uint16_t tickstamp) { 51 | set16BitValue(tickstamp, TORQUETICKSTAMP_LSB_BYTE, 52 | TORQUETICKSTAMP_MSB_BYTE); 53 | } 54 | -------------------------------------------------------------------------------- /src/Profiles/Environment/DataPages/ANTPLUS_EnvironmentTemperature.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define EVENTCOUNT_BYTE 2 5 | #define LOW24HOUR_LSB_BYTE 3 6 | #define LOW24HOUR_MSB_BYTE 4 7 | #define LOW24HOUR_MSB_MASK 0xF0 8 | #define LOW24HOUR_MSB_SHIFT 4 9 | #define HIGH24HOUR_LSB_BYTE 4 10 | #define HIGH24HOUR_MSB_BYTE 5 11 | #define HIGH24HOUR_LSB_MASK 0x0F 12 | #define HIGH24HOUR_MSB_SHIFT 4 13 | #define CURRENTTEMP_LSB_BYTE 6 14 | #define CURRENTTEMP_MSB_BYTE 7 15 | 16 | template 17 | EnvironmentBaseTemperature::EnvironmentBaseTemperature() : 18 | CoreDataPage() {} 19 | 20 | template 21 | uint8_t EnvironmentBaseTemperature::getEventCount() { 22 | return this->get8BitValue(EVENTCOUNT_BYTE); 23 | } 24 | 25 | /* NOTE: this is a non-contigous data field, which resuls in the shenanigans below */ 26 | template 27 | int16_t EnvironmentBaseTemperature::get24HourLow() { 28 | int16_t low = this->get8BitValue(LOW24HOUR_MSB_BYTE, LOW24HOUR_MSB_MASK); 29 | low <<= LOW24HOUR_MSB_SHIFT; 30 | low |= this->get8BitValue(LOW24HOUR_LSB_BYTE); 31 | // extend bits if negative 32 | low = (0x800 & low) ? low | 0xF000 : low; 33 | return low; 34 | } 35 | 36 | /* NOTE: this is a non-contigous data field, which resuls in the shenanigans below */ 37 | template 38 | int16_t EnvironmentBaseTemperature::get24HourHigh() { 39 | int16_t high = this->get8BitValue(HIGH24HOUR_MSB_BYTE); 40 | high <<= HIGH24HOUR_MSB_SHIFT; 41 | high |= this->get8BitValue(HIGH24HOUR_LSB_BYTE, HIGH24HOUR_LSB_MASK); 42 | // extend bits if negative 43 | high = (0x800 & high) ? high | 0xF000 : high; 44 | return high; 45 | } 46 | 47 | template 48 | int16_t EnvironmentBaseTemperature::getCurrentTemp() { 49 | return this->get16BitValue(CURRENTTEMP_LSB_BYTE, CURRENTTEMP_MSB_BYTE); 50 | } 51 | 52 | template class EnvironmentBaseTemperature; 53 | template class EnvironmentBaseTemperature; 54 | 55 | EnvironmentTemperature::EnvironmentTemperature(AntRxDataResponse& dp) : 56 | EnvironmentBaseDataPage(dp), 57 | EnvironmentBaseTemperature() {} 58 | 59 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_ManufacturersInformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define HWREVISION_BYTE 3 6 | #define MANUFACTURERID_LSB_BYTE 4 7 | #define MANUFACTURERID_MSB_BYTE 5 8 | #define MODELNUMBER_LSB_BYTE 6 9 | #define MODELNUMBER_MSB_BYTE 7 10 | #define RESERVED_LSB_BYTE 1 11 | #define RESERVED_MSB_BYTE 2 12 | #define RESERVED_VALUE 0xFFFF 13 | 14 | template 15 | BaseManufacturersInformation::BaseManufacturersInformation() : 16 | CoreDataPage() {} 17 | 18 | template 19 | uint8_t BaseManufacturersInformation::getHWRevision() { 20 | return this->get8BitValue(HWREVISION_BYTE); 21 | } 22 | 23 | template 24 | uint16_t BaseManufacturersInformation::getManufacturerID() { 25 | return this->get16BitValue(MANUFACTURERID_LSB_BYTE, 26 | MANUFACTURERID_MSB_BYTE); 27 | } 28 | 29 | template 30 | uint16_t BaseManufacturersInformation::getModelNumber() { 31 | return this->get16BitValue(MODELNUMBER_LSB_BYTE, MODELNUMBER_MSB_BYTE); 32 | } 33 | 34 | template class BaseManufacturersInformation; 35 | template class BaseManufacturersInformation; 36 | 37 | ManufacturersInformation::ManufacturersInformation(AntRxDataResponse& dp) : 38 | BaseDataPage(dp), 39 | BaseManufacturersInformation() {} 40 | 41 | ManufacturersInformationMsg::ManufacturersInformationMsg() : 42 | BaseDataPageMsg(), 43 | BaseManufacturersInformation() { 44 | setDataBuffer(_buffer); 45 | set8BitValue(ANTPLUS_COMMON_DATAPAGE_MANUFACTURERSINFORMATION_NUMBER, 46 | ANTPLUS_DEFAULT_DATAPAGE_BYTE); 47 | set16BitValue(RESERVED_VALUE, RESERVED_LSB_BYTE, RESERVED_MSB_BYTE); 48 | } 49 | 50 | void ManufacturersInformationMsg::setHWRevision(uint8_t revision) { 51 | set8BitValue(revision, HWREVISION_BYTE); 52 | } 53 | 54 | void ManufacturersInformationMsg::setManufacturerId(uint16_t id) { 55 | set16BitValue(id, MANUFACTURERID_LSB_BYTE, MANUFACTURERID_MSB_BYTE); 56 | } 57 | 58 | void ManufacturersInformationMsg::setModelNumber(uint16_t modelNumber) { 59 | set16BitValue(modelNumber, MODELNUMBER_LSB_BYTE, MODELNUMBER_MSB_BYTE); 60 | } 61 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/ANTPLUS_HeartRateDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_HEARTRATEPROFILEDEFINES_h 2 | #define ANTPLUS_HEARTRATEPROFILEDEFINES_h 3 | 4 | #define ANTPLUS_HEARTRATE_DEVICETYPE 120 5 | 6 | #define ANTPLUS_HEARTRATE_FLAGS_EXTENTED_FEATURES (1 << 0) 7 | 8 | /* DataPage Numbers */ 9 | #define ANTPLUS_HEARTRATE_DATAPAGE_DEFAULT_NUMBER 0 10 | 11 | 12 | #define ANTPLUS_HEARTRATE_DATAPAGE_CUMULATIVEOPERATINGTIME_NUMBER 1 13 | 14 | 15 | #define ANTPLUS_HEARTRATE_DATAPAGE_MANUFACTURERINFORMATION_NUMBER 2 16 | 17 | 18 | #define ANTPLUS_HEARTRATE_DATAPAGE_PRODUCTINFORMATION_NUMBER 3 19 | 20 | 21 | #define ANTPLUS_HEARTRATE_DATAPAGE_PREVIOUSHEARTBEAT_NUMBER 4 22 | 23 | #define ANTPLUS_HEARTRATE_DATAPAGE_PREVIOUSHEARTBEAT_MANUFACTURERSPECIFIC_INVALID 0xFF 24 | 25 | 26 | #define ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_NUMBER 5 27 | 28 | #define ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_INTERVALAVERAGEHEARTRATE_INVALID 0 29 | #define ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_INTERVALMAXIMUMHEARTRATE_INVALID 0 30 | #define ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_SESSIONAVERAGEHEARTRATE_INVALID 0 31 | 32 | 33 | #define ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_NUMBER 6 34 | 35 | #define ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_FEATURES_EXTENDEDRUNNING 0x01 36 | #define ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_FEATURES_EXTENDEDCYCLING 0x02 37 | #define ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_FEATURES_EXTENDEDSWIMMING 0x04 38 | #define ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_FEATURES_MANUFACTURER1 0x40 39 | #define ANTPLUS_HEARTRATE_DATAPAGE_CAPABILITIES_FEATURES_MANUFACTURER2 0x80 40 | 41 | 42 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_NUMBER 7 43 | 44 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYLEVEL_INVALID 0xFF 45 | 46 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_COARSEBATTERYVOLTAGE_INVALID 0xF 47 | 48 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_NEW 1 49 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_GOOD 2 50 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_OK 3 51 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_LOW 4 52 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_CRITICAL 5 53 | #define ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_INVALID 7 54 | 55 | #endif // ANTPLUS_HEARTRATEPROFILEDEFINES_h 56 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevSpeedSystemInformation2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define BATTERYSOC_BYTE 1 5 | #define BATTERYSOC_STATEOFCHARGE_MASK 0x7F 6 | #define BATTERYSOC_BATTERYEMPTY_SHIFT 7 7 | #define BATTERYSOC_BATTERYEMPTY_MASK 0x80 8 | #define PERCENTASSIST_BYTE 5 9 | #define RESERVED_BYTE 7 10 | #define RESERVED_MASK 0xF 11 | #define RESERVED_SHIFT 4 12 | 13 | template 14 | LevBaseSpeedSystemInformation2::LevBaseSpeedSystemInformation2() : 15 | CoreDataPage() {} 16 | 17 | template 18 | uint8_t LevBaseSpeedSystemInformation2::getBatterySOC() { 19 | return this->get8BitValue(BATTERYSOC_BYTE, BATTERYSOC_STATEOFCHARGE_MASK); 20 | } 21 | 22 | template 23 | uint8_t LevBaseSpeedSystemInformation2::getBatteryEmptyWarning() { 24 | return this->get8BitValue(BATTERYSOC_BYTE, 25 | BATTERYSOC_BATTERYEMPTY_MASK, 26 | BATTERYSOC_BATTERYEMPTY_SHIFT); 27 | } 28 | 29 | template 30 | uint8_t LevBaseSpeedSystemInformation2::getPercentAssist() { 31 | return this->get8BitValue(PERCENTASSIST_BYTE); 32 | } 33 | 34 | template class LevBaseSpeedSystemInformation2; 35 | template class LevBaseSpeedSystemInformation2; 36 | 37 | LevSpeedSystemInformation2::LevSpeedSystemInformation2(AntRxDataResponse& dp) : 38 | LevBaseSpeedSystemInformation(dp), 39 | LevBaseSpeedSystemInformation2() {} 40 | 41 | LevSpeedSystemInformation2Msg::LevSpeedSystemInformation2Msg() : 42 | LevBaseSpeedSystemInformationMsg(ANTPLUS_LEV_DATAPAGE_SPEEDSYSTEMINFORMATION2_NUMBER), 43 | LevBaseSpeedSystemInformation2() { 44 | set8BitValue(RESERVED_BYTE, RESERVED_MASK, RESERVED_SHIFT); 45 | } 46 | 47 | void LevSpeedSystemInformation2Msg::setBatterySOC(uint8_t soc) { 48 | set8BitValue(soc, BATTERYSOC_BYTE, BATTERYSOC_STATEOFCHARGE_MASK); 49 | } 50 | 51 | void LevSpeedSystemInformation2Msg::setBatteryEmptyWarning(uint8_t warning) { 52 | set8BitValue(warning, BATTERYSOC_BYTE, BATTERYSOC_BATTERYEMPTY_MASK, 53 | BATTERYSOC_BATTERYEMPTY_SHIFT); 54 | } 55 | 56 | void LevSpeedSystemInformation2Msg::setPercentAssist(uint8_t percent) { 57 | set8BitValue(percent, PERCENTASSIST_BYTE); 58 | } 59 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateSwimIntervalSummary.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define INTERVALAVERAGEHEARTRATE_BYTE 1 6 | #define INTERVALMAXIMUMHEARTRATE_BYTE 2 7 | #define SESSIONAVERAGEHEARTRATE_BYTE 3 8 | 9 | template 10 | HeartRateBaseSwimIntervalSummary::HeartRateBaseSwimIntervalSummary() : 11 | CoreDataPage() {} 12 | 13 | template 14 | uint8_t HeartRateBaseSwimIntervalSummary::getIntervalAverageHeartRate() { 15 | return this->get8BitValue(INTERVALAVERAGEHEARTRATE_BYTE); 16 | } 17 | 18 | template 19 | uint8_t HeartRateBaseSwimIntervalSummary::getIntervalMaximumHeartRate() { 20 | return this->get8BitValue(INTERVALMAXIMUMHEARTRATE_BYTE); 21 | } 22 | 23 | template 24 | uint8_t HeartRateBaseSwimIntervalSummary::getSessionAverageHeartRate() { 25 | return this->get8BitValue(SESSIONAVERAGEHEARTRATE_BYTE); 26 | } 27 | 28 | template class HeartRateBaseSwimIntervalSummary; 29 | template class HeartRateBaseSwimIntervalSummary; 30 | 31 | HeartRateSwimIntervalSummary::HeartRateSwimIntervalSummary(AntRxDataResponse& dp) : 32 | HeartRateBaseMainDataPage(dp), 33 | HeartRateBaseSwimIntervalSummary() {} 34 | 35 | HeartRateSwimIntervalSummaryMsg::HeartRateSwimIntervalSummaryMsg() : 36 | HeartRateBaseMainDataPageMsg(HEARTRATE_SWIMINTERVALSUMMARY_NUMBER), 37 | HeartRateBaseSwimIntervalSummary() { 38 | setIntervalAverageHeartRate(ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_INTERVALAVERAGEHEARTRATE_INVALID); 39 | setIntervalMaximumHeartRate(ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_INTERVALMAXIMUMHEARTRATE_INVALID); 40 | setSessionAverageHeartRate(ANTPLUS_HEARTRATE_DATAPAGE_SWIMINTERVALSUMMARY_SESSIONAVERAGEHEARTRATE_INVALID); 41 | } 42 | 43 | void HeartRateSwimIntervalSummaryMsg::setIntervalAverageHeartRate(uint8_t intervalAverage) { 44 | set8BitValue(intervalAverage, INTERVALAVERAGEHEARTRATE_BYTE); 45 | } 46 | 47 | void HeartRateSwimIntervalSummaryMsg::setIntervalMaximumHeartRate(uint8_t intervalMaximum) { 48 | set8BitValue(intervalMaximum, INTERVALMAXIMUMHEARTRATE_BYTE); 49 | } 50 | 51 | void HeartRateSwimIntervalSummaryMsg::setSessionAverageHeartRate(uint8_t sessionAverage) { 52 | set8BitValue(sessionAverage, SESSIONAVERAGEHEARTRATE_BYTE); 53 | } 54 | 55 | -------------------------------------------------------------------------------- /src/Profiles/Fec/Profiles/ANTPLUS_FecProfileDisplay.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEFECDISPLAY_h 2 | #define ANTPLUS_PROFILEFECDISPLAY_h 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class ProfileFecDisplay : public BaseSlaveProfile { 9 | public: 10 | ProfileFecDisplay(uint16_t deviceNumber = 0, uint8_t transmissionType = 0); 11 | void onFecTrainerData(void (*func)(FecSpecificTrainerData&, uintptr_t), uintptr_t data = 0) { _onFecSpecificTrainerData.set(func, data); } 12 | void onManufacturersInformation(void (*func)(ManufacturersInformation&, uintptr_t), uintptr_t data = 0) { _onManufacturersInformation.set(func, data); } 13 | void onProductInformation(void (*func)(ProductInformation&, uintptr_t), uintptr_t data = 0) { _onProductInformation.set(func, data); } 14 | void onFecGeneralFeData(void (*func)(FecGeneralFeData&, uintptr_t), uintptr_t data = 0) { _onFecGeneralFeData.set(func, data); } 15 | void onFecGeneralSettingsPage(void (*func)(FecGeneralSettingsPage&, uintptr_t), uintptr_t data = 0) { _onFecGeneralSettingsPage.set(func, data); } 16 | void onFecFeCapabilities(void (*func)(FecFeCapabilities&, uintptr_t), uintptr_t data = 0) { _onFecFeCapabilities.set(func, data); } 17 | 18 | private: 19 | void setChannelConfig(); 20 | void onBroadcastData(BroadcastData& msg) override; 21 | void onAcknowledgedData(AcknowledgedData& msg) override; 22 | 23 | bool handleDataPage(FecBaseMainDataPage& dp); 24 | bool handleManufacturerInformation(FecBaseMainDataPage& dataPage); 25 | bool handleProductInformation(FecBaseMainDataPage& dataPage); 26 | bool handleGeneralFeData(FecBaseMainDataPage& dataPage); 27 | bool handleGeneralSettingsPage(FecBaseMainDataPage& dataPage); 28 | bool handleTrainerData(FecBaseMainDataPage& dataPage); 29 | bool handleFeCapabilities(FecBaseMainDataPage& dataPage); 30 | 31 | AntCallback _onFecSpecificTrainerData = { .func = NULL }; 32 | AntCallback _onManufacturersInformation = { .func = NULL }; 33 | AntCallback _onProductInformation = { .func = NULL }; 34 | AntCallback _onFecGeneralFeData = { .func = NULL }; 35 | AntCallback _onFecGeneralSettingsPage = { .func = NULL }; 36 | AntCallback _onFecFeCapabilities = { .func = NULL }; 37 | }; 38 | 39 | #endif // ANTPLUS_PROFILEFECDISPLAY_h 40 | -------------------------------------------------------------------------------- /src/Profiles/Lev/DataPages/ANTPLUS_LevCapabilities.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define TRAVELMODESSUPPORTED_BYTE 2 5 | #define TRAVELMODESSUPPORTED_NUMBERASSISTMODES_MASK 0x38 6 | #define TRAVELMODESSUPPORTED_NUMBERASSISTMODES_SHIFT 3 7 | #define TRAVELMODESSUPPORTED_NUMBERREGENERATIVEMODES_MASK 0x7 8 | #define WHEELCIRCUMFERENCE_LSB_BYTE 3 9 | #define WHEELCIRCUMFERENCE_MSB_BYTE 4 10 | #define WHEELCIRCUMFERENCE_MASK 0xFFF 11 | 12 | template 13 | LevBaseCapabilities::LevBaseCapabilities() : CoreDataPage() {} 14 | 15 | template 16 | uint8_t LevBaseCapabilities::getNumberOfAssistModesSupported() { 17 | return this->get8BitValue(TRAVELMODESSUPPORTED_BYTE, 18 | TRAVELMODESSUPPORTED_NUMBERASSISTMODES_MASK, 19 | TRAVELMODESSUPPORTED_NUMBERASSISTMODES_SHIFT); 20 | } 21 | 22 | template 23 | uint8_t LevBaseCapabilities::getNumberOfRegenerativeModesSupported() { 24 | return this->get8BitValue(TRAVELMODESSUPPORTED_BYTE, 25 | TRAVELMODESSUPPORTED_NUMBERREGENERATIVEMODES_MASK); 26 | } 27 | 28 | template 29 | uint16_t LevBaseCapabilities::getWheelCircumference() { 30 | return this->get16BitValue(WHEELCIRCUMFERENCE_LSB_BYTE, 31 | WHEELCIRCUMFERENCE_MSB_BYTE, WHEELCIRCUMFERENCE_MASK); 32 | } 33 | 34 | template class LevBaseCapabilities; 35 | template class LevBaseCapabilities; 36 | 37 | LevCapabilities::LevCapabilities(AntRxDataResponse& dp) : 38 | LevBaseMainDataPage(dp), LevBaseCapabilities() {} 39 | 40 | LevCapabilitiesMsg::LevCapabilitiesMsg() : 41 | LevBaseMainDataPageMsg(ANTPLUS_LEV_DATAPAGE_LEVCAPABILITIES_NUMBER), 42 | LevBaseCapabilities() {} 43 | 44 | void LevCapabilitiesMsg::setNumberOfAssistModesSupported(uint8_t modes) { 45 | set8BitValue(modes, TRAVELMODESSUPPORTED_BYTE, 46 | TRAVELMODESSUPPORTED_NUMBERASSISTMODES_MASK, 47 | TRAVELMODESSUPPORTED_NUMBERASSISTMODES_SHIFT); 48 | } 49 | 50 | void LevCapabilitiesMsg::setNumberOfRegenerativeModesSupported(uint8_t modes) { 51 | set8BitValue(modes, TRAVELMODESSUPPORTED_BYTE, 52 | TRAVELMODESSUPPORTED_NUMBERREGENERATIVEMODES_MASK); 53 | } 54 | 55 | void LevCapabilitiesMsg::setWheelCircumference(uint16_t circumference) { 56 | set16BitValue(circumference, WHEELCIRCUMFERENCE_LSB_BYTE, 57 | WHEELCIRCUMFERENCE_MSB_BYTE, WHEELCIRCUMFERENCE_MASK); 58 | } 59 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerStandardCrankTorque.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define CRANKTICKS_BYTE 2 5 | #define INSTANTANEOUSCADENCE_BYTE 3 6 | #define PERIOD_LSB_BYTE 4 7 | #define PERIOD_MSB_BYTE 5 8 | #define ACCUMULATEDTORQUE_LSB_BYTE 6 9 | #define ACCUMULATEDTORQUE_MSB_BYTE 7 10 | 11 | template 12 | BicyclePowerBaseStandardCrankTorque::BicyclePowerBaseStandardCrankTorque() : 13 | CoreDataPage() {} 14 | 15 | template 16 | uint8_t BicyclePowerBaseStandardCrankTorque::getCrankTicks() { 17 | return this->get8BitValue(CRANKTICKS_BYTE); 18 | } 19 | 20 | template 21 | uint8_t BicyclePowerBaseStandardCrankTorque::getInstantaneousCadence() { 22 | return this->get8BitValue(INSTANTANEOUSCADENCE_BYTE); 23 | } 24 | 25 | template 26 | uint16_t BicyclePowerBaseStandardCrankTorque::getCrankPeriod() { 27 | return this->get16BitValue(PERIOD_LSB_BYTE, PERIOD_MSB_BYTE); 28 | } 29 | 30 | template 31 | uint16_t BicyclePowerBaseStandardCrankTorque::getAccumulatedTorque() { 32 | return this->get16BitValue( 33 | ACCUMULATEDTORQUE_LSB_BYTE, ACCUMULATEDTORQUE_MSB_BYTE); 34 | } 35 | 36 | template class BicyclePowerBaseStandardCrankTorque; 37 | template class BicyclePowerBaseStandardCrankTorque; 38 | 39 | BicyclePowerStandardCrankTorque::BicyclePowerStandardCrankTorque(AntRxDataResponse& dp) : 40 | BicyclePowerBaseMainDataPage(dp), 41 | BicyclePowerBaseStandardCrankTorque() {} 42 | 43 | BicyclePowerStandardCrankTorqueMsg::BicyclePowerStandardCrankTorqueMsg() : 44 | BicyclePowerBaseMainDataPageMsg(ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDCRANKTORQUE_NUMBER), 45 | BicyclePowerBaseStandardCrankTorque() { 46 | setInstantaneousCadence(ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDCRANKTORQUE_INSTANTANEOUSCADENCE_INVALID); 47 | } 48 | 49 | void BicyclePowerStandardCrankTorqueMsg::setCrankTicks(uint8_t ticks) { 50 | set8BitValue(ticks, CRANKTICKS_BYTE); 51 | } 52 | void BicyclePowerStandardCrankTorqueMsg::setInstantaneousCadence(uint8_t cadence) { 53 | set8BitValue(cadence, INSTANTANEOUSCADENCE_BYTE); 54 | } 55 | 56 | void BicyclePowerStandardCrankTorqueMsg::setCrankPeriod(uint16_t period) { 57 | set16BitValue(period, PERIOD_LSB_BYTE, PERIOD_MSB_BYTE); 58 | } 59 | 60 | void BicyclePowerStandardCrankTorqueMsg::setAccumulatedTorque(uint16_t torque) { 61 | set16BitValue(torque, ACCUMULATEDTORQUE_LSB_BYTE, ACCUMULATEDTORQUE_MSB_BYTE); 62 | } 63 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseMasterProfile.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_BASEMASTERPROFILE_h 2 | #define ANTPLUS_BASEMASTERPROFILE_h 3 | 4 | #include 5 | #include 6 | 7 | class BaseMasterProfile : public BaseProfile { 8 | public: 9 | BaseMasterProfile(uint16_t deviceNumber, uint8_t transmissionType); 10 | /** 11 | * start profile transmission sequence 12 | */ 13 | virtual void begin() override; 14 | protected: 15 | /** 16 | * Used to catch EVENT_TX and continue transmission pattern 17 | * Also handles EVENT_TRANSFER_TX_COMPLETED for acknowledgement 18 | */ 19 | virtual void onChannelEventResponse(ChannelEventResponse& msg) override; 20 | /** 21 | * This function, when called, will transmit the next message in the broadcast pattern 22 | */ 23 | virtual void transmitNextDataPage() = 0; 24 | /** 25 | * Checks for RequestDataPage messages and handles them accordingly 26 | */ 27 | virtual void onAcknowledgedData(AcknowledgedData& msg) override; 28 | /** 29 | * Checks with subclass to see if request is valid 30 | */ 31 | virtual bool isDataPageValid(uint8_t dataPage) = 0; 32 | /** 33 | * returns true if pattern is currently interrupted by a request 34 | */ 35 | bool isRequestedPagePending(); 36 | /** 37 | * Returns the page number of the pending datapage 38 | */ 39 | uint8_t getRequestedPage(); 40 | /** 41 | * returns true if the request is meant to be sent as a acknowledged message 42 | */ 43 | bool isRequestedPageAcknowledged(); 44 | /** 45 | * Allows a profile to further validate datapage requests and invludate at a later 46 | * time if deemed appropriate. An example is the descriptor byte fields. 47 | */ 48 | void invalidateDataPageRequest(); 49 | /** 50 | * Some profiles are forbidden from replying with ACK messages, this allows the profile 51 | * to disable automatic request conversions; 52 | */ 53 | void setAckMessageUsage(bool on); 54 | /** 55 | * Handles ack msg conversions for requests, all transmissions that are part of the broadcast pattern should be through this. 56 | */ 57 | void transmitMsg(BaseDataPageMsg &msg); 58 | void transmitMsg(BaseDataPageMsg &msg); 59 | private: 60 | void handleRequestDataPage(AcknowledgedData& msg); 61 | uint8_t _requestedPage = 0; 62 | uint8_t _requestedCount = 0; 63 | bool _ackMessagesAllowed = true; 64 | bool _isRequestAcknowledged = false; 65 | bool _requestAcked = true; 66 | }; 67 | 68 | #endif // ANTPLUS_BASESLAVEPROFILE_h 69 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/Monitor/ANTPLUS_ProfileMuscleOxygenMonitor.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEMUSCLEOXYGENMONITOR_h 2 | #define ANTPLUS_PROFILEMUSCLEOXYGENMONITOR_h 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class ProfileMuscleOxygenMonitor : public BaseMasterProfile { 10 | public: 11 | explicit ProfileMuscleOxygenMonitor(uint16_t deviceNumber, uint8_t transmissionType = 0, uint32_t flags = 0); 12 | 13 | /** 14 | * Register callback to populate Muscle Oxygen data messages (Datapage 0x01) 15 | */ 16 | void createMuscleOxygenMuscleOxygenDataMsg(void(*func)(MuscleOxygenMuscleOxygenDataMsg&, uintptr_t), uintptr_t data = 0) { _createMuscleOxygenMuscleOxygenDataMsg.set(func, data); } 17 | /** 18 | * Register callback to populate manufacturer information data messages (Datapage 0x50) 19 | */ 20 | void createManufacturerInformationMsg(void(*func)(ManufacturersInformationMsg&, uintptr_t), uintptr_t data = 0) { _createManufacturersInformationMsg.set(func, data); } 21 | /** 22 | * Register callback to populate product information data messages (Datapage 0x51) 23 | */ 24 | void createProductInformationMsg(void(*func)(ProductInformationMsg&, uintptr_t), uintptr_t data = 0) { _createProductInformationMsg.set(func, data); } 25 | /** 26 | * Register callback to populate battery status data messages (Datapage 0x52) 27 | */ 28 | void createProductInformationMsg(void(*func)(BatteryStatusMsg&, uintptr_t), uintptr_t data = 0) { _createBatteryStatusMsg.set(func, data); } 29 | 30 | protected: 31 | void transmitNextDataPage() override; 32 | bool isDataPageValid(uint8_t dataPage) override; 33 | 34 | private: 35 | void setChannelConfig(); 36 | void transmitMuscleOxygenMuscleOxygenDataMsg(); 37 | void transmitManufacturerInformationMsg(); 38 | void transmitProductInformationMsg(); 39 | void transmitBatteryStatusMsg(); 40 | 41 | uint8_t _patternStep = 0; 42 | uint8_t _backgroundStep = 0; 43 | uint8_t _backgroundStepSize = 0; 44 | uint32_t _flags; 45 | 46 | AntCallback _createMuscleOxygenMuscleOxygenDataMsg = { .func = NULL }; 47 | AntCallback _createManufacturersInformationMsg = { .func = NULL }; 48 | AntCallback _createProductInformationMsg = { .func = NULL }; 49 | AntCallback _createBatteryStatusMsg = { .func = NULL }; 50 | }; 51 | 52 | #endif // ANTPLUS_PROFILEMUSCLEOXYGENMONITOR_h 53 | -------------------------------------------------------------------------------- /test/test_basedatapage/Test_BaseDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include "unity.h" 2 | #include "Util/Testing.h" 3 | #include "ANTPLUS.h" 4 | #include "BaseDataPageTests.h" 5 | 6 | #ifdef UNIT_TEST 7 | 8 | static uint8_t mockedInput8bit[] = {0, 0, 0, 0, 0, 0, 0, 0, 0xFE}; 9 | static uint8_t mockedInput16bit[] = {0, 0xAB, 0xCD, 0, 0, 0, 0, 0, 0}; 10 | static uint8_t mockedInput24bit[] = {0, 0, 0, 0, 0x9A, 0xBC, 0xDE, 0, 0}; 11 | static uint8_t mockedInput32bit[] = {0, 0x12, 0x34, 0x56, 0x78, 0, 0, 0, 0}; 12 | static BroadcastData bd; 13 | static BaseDataPage *dp; 14 | 15 | static void test_8BitGet(void) { 16 | uint8_t temp; 17 | dp->setFrameData(mockedInput8bit); 18 | temp = dp->get8BitValue(7); 19 | TEST_ASSERT_EQUAL_UINT8(0xFE, temp); 20 | temp = dp->get8BitValue(7, 0xA0); 21 | TEST_ASSERT_EQUAL_UINT8(0xA0, temp); 22 | temp = dp->get8BitValue(7, 0xA0, 4); 23 | TEST_ASSERT_EQUAL_UINT8(0xA, temp); 24 | temp = dp->get8BitValue(6); 25 | TEST_ASSERT_EQUAL_UINT8(0, temp); 26 | } 27 | 28 | static void test_16BitGet(void) { 29 | uint16_t temp; 30 | dp->setFrameData(mockedInput16bit); 31 | temp = dp->get16BitValue(0, 1); 32 | TEST_ASSERT_EQUAL_UINT16(0xCDAB, temp); 33 | temp = dp->get16BitValue(1, 0, 0xA0C0); 34 | TEST_ASSERT_EQUAL_UINT16(0xA0C0, temp); 35 | temp = dp->get16BitValue(1, 0, 0x0FF0, 4); 36 | TEST_ASSERT_EQUAL_UINT16(0xBC, temp); 37 | temp = dp->get16BitValue(6, 7); 38 | TEST_ASSERT_EQUAL_UINT16(0, temp); 39 | } 40 | 41 | static void test_24BitGet(void) { 42 | uint32_t temp; 43 | dp->setFrameData(mockedInput24bit); 44 | temp = dp->get24BitValue(3, 5); 45 | TEST_ASSERT_EQUAL_UINT32(0xDEBC9A, temp); 46 | temp = dp->get24BitValue(5, 3, 0x0FFFFF); 47 | TEST_ASSERT_EQUAL_UINT32(0xABCDE, temp); 48 | temp = dp->get24BitValue(5, 3, 0x0FFFF0, 4); 49 | TEST_ASSERT_EQUAL_UINT32(0xABCD, temp); 50 | temp = dp->get24BitValue(0, 2); 51 | TEST_ASSERT_EQUAL_UINT32(0, temp); 52 | } 53 | 54 | static void test_32BitGet(void) { 55 | uint32_t temp; 56 | dp->setFrameData(mockedInput32bit); 57 | temp = dp->get32BitValue(0, 3); 58 | TEST_ASSERT_EQUAL_UINT32(0x78563412, temp); 59 | temp = dp->get32BitValue(3, 0, 0x0FFFFFFF); 60 | TEST_ASSERT_EQUAL_UINT32(0x02345678, temp); 61 | temp = dp->get32BitValue(3, 0, 0x0FFFFFF0, 4); 62 | TEST_ASSERT_EQUAL_UINT32(0x0234567, temp); 63 | temp = dp->get32BitValue(4, 7); 64 | TEST_ASSERT_EQUAL_UINT32(0, temp); 65 | } 66 | 67 | void runBaseDataPageTests() { 68 | dp = new BaseDataPage(bd); 69 | RUN_TEST(test_8BitGet); 70 | RUN_TEST(test_16BitGet); 71 | RUN_TEST(test_24BitGet); 72 | RUN_TEST(test_32BitGet); 73 | } 74 | 75 | #endif // UNIT_TEST 76 | -------------------------------------------------------------------------------- /src/Profiles/BicyclePower/DataPages/ANTPLUS_BicyclePowerStandardWheelTorque.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define WHEELTICKS_BYTE 2 5 | #define INSTANTANEOUSCADENCE_BYTE 3 6 | #define WHEELPERIOD_LSB_BYTE 4 7 | #define WHEELPERIOD_MSB_BYTE 5 8 | #define ACCUMULATEDTORQUE_LSB_BYTE 6 9 | #define ACCUMULATEDTORQUE_MSB_BYTE 7 10 | 11 | template 12 | BicyclePowerBaseStandardWheelTorque::BicyclePowerBaseStandardWheelTorque() : 13 | CoreDataPage() {} 14 | 15 | template 16 | uint8_t BicyclePowerBaseStandardWheelTorque::getWheelTicks() { 17 | return this->get8BitValue(WHEELTICKS_BYTE); 18 | } 19 | 20 | template 21 | uint8_t BicyclePowerBaseStandardWheelTorque::getInstantaneousCadence() { 22 | return this->get8BitValue(INSTANTANEOUSCADENCE_BYTE); 23 | } 24 | 25 | template 26 | uint16_t BicyclePowerBaseStandardWheelTorque::getWheelPeriod() { 27 | return this->get16BitValue(WHEELPERIOD_LSB_BYTE, WHEELPERIOD_MSB_BYTE); 28 | } 29 | 30 | template 31 | uint16_t BicyclePowerBaseStandardWheelTorque::getAccumulatedTorque() { 32 | return this->get16BitValue( 33 | ACCUMULATEDTORQUE_LSB_BYTE, ACCUMULATEDTORQUE_MSB_BYTE); 34 | } 35 | 36 | template class BicyclePowerBaseStandardWheelTorque; 37 | template class BicyclePowerBaseStandardWheelTorque; 38 | 39 | BicyclePowerStandardWheelTorque::BicyclePowerStandardWheelTorque(AntRxDataResponse& dp) : 40 | BicyclePowerBaseMainDataPage(dp), 41 | BicyclePowerBaseStandardWheelTorque() {} 42 | 43 | BicyclePowerStandardWheelTorqueMsg::BicyclePowerStandardWheelTorqueMsg() : 44 | BicyclePowerBaseMainDataPageMsg(ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDWHEELTORQUE_NUMBER), 45 | BicyclePowerBaseStandardWheelTorque() { 46 | setInstantaneousCadence(ANTPLUS_BICYCLEPOWER_DATAPAGES_STANDARDWHEELTORQUE_INSTANTANEOUSCADENCE_INVALID); 47 | } 48 | 49 | void BicyclePowerStandardWheelTorqueMsg::setWheelTicks(uint8_t ticks) { 50 | set8BitValue(ticks, WHEELTICKS_BYTE); 51 | } 52 | 53 | void BicyclePowerStandardWheelTorqueMsg::setInstantaneousCadence(uint8_t cadence) { 54 | set8BitValue(cadence, INSTANTANEOUSCADENCE_BYTE); 55 | } 56 | 57 | void BicyclePowerStandardWheelTorqueMsg::setWheelPeriod(uint16_t period) { 58 | set16BitValue(period, WHEELPERIOD_LSB_BYTE, WHEELPERIOD_MSB_BYTE); 59 | } 60 | 61 | void BicyclePowerStandardWheelTorqueMsg::setAccumulatedTorque(uint16_t torque) { 62 | set16BitValue(torque, ACCUMULATEDTORQUE_LSB_BYTE, 63 | ACCUMULATEDTORQUE_MSB_BYTE); 64 | } 65 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateBatteryStatus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define BATTERYLEVEL_BYTE 1 5 | #define FRACTIONALBATTERYVOLTAGE_BYTE 2 6 | #define COARSEBATTERYVOLTAGE_BYTE 3 7 | #define BATTERYSTATUS_BYTE 3 8 | #define COARSEBATTERYVOLTAGE_MASK 0x0F 9 | #define BATTERYSTATUS_MASK 0x70 10 | #define BATTERYSTATUS_SHIFT 4 11 | 12 | template 13 | HeartRateBaseBatteryStatus::HeartRateBaseBatteryStatus() : 14 | CoreDataPage() {} 15 | 16 | template 17 | uint8_t HeartRateBaseBatteryStatus::getBatteryLevel() { 18 | return this->get8BitValue(BATTERYLEVEL_BYTE); 19 | } 20 | 21 | template 22 | uint8_t HeartRateBaseBatteryStatus::getFractionalBatteryVoltage() { 23 | return this->get8BitValue(FRACTIONALBATTERYVOLTAGE_BYTE); 24 | } 25 | 26 | template 27 | uint8_t HeartRateBaseBatteryStatus::getCoarseBatteryVoltage() { 28 | return this->get8BitValue( 29 | COARSEBATTERYVOLTAGE_BYTE, COARSEBATTERYVOLTAGE_MASK); 30 | } 31 | 32 | template 33 | uint8_t HeartRateBaseBatteryStatus::getBatteryStatus() { 34 | return this->get8BitValue( 35 | BATTERYSTATUS_BYTE, BATTERYSTATUS_MASK, BATTERYSTATUS_SHIFT); 36 | } 37 | 38 | template class HeartRateBaseBatteryStatus; 39 | template class HeartRateBaseBatteryStatus; 40 | 41 | HeartRateBatteryStatus::HeartRateBatteryStatus(AntRxDataResponse& dp) : 42 | HeartRateBaseMainDataPage(dp), 43 | HeartRateBaseBatteryStatus() {} 44 | 45 | HeartRateBatteryStatusMsg::HeartRateBatteryStatusMsg() : 46 | HeartRateBaseMainDataPageMsg(ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_NUMBER), 47 | HeartRateBaseBatteryStatus() { 48 | setBatteryLevel(ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYLEVEL_INVALID); 49 | setCoarseBatteryVolage(ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_COARSEBATTERYVOLTAGE_INVALID); 50 | setBatteryStatus(ANTPLUS_HEARTRATE_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_INVALID); 51 | } 52 | 53 | void HeartRateBatteryStatusMsg::setBatteryLevel(uint8_t level) { 54 | set8BitValue(level, BATTERYLEVEL_BYTE); 55 | } 56 | 57 | void HeartRateBatteryStatusMsg::setFractionalBatteryVoltage(uint8_t voltage) { 58 | set8BitValue(voltage, FRACTIONALBATTERYVOLTAGE_BYTE); 59 | } 60 | 61 | void HeartRateBatteryStatusMsg::setCoarseBatteryVolage(uint8_t voltage) { 62 | set8BitValue(voltage, COARSEBATTERYVOLTAGE_BYTE, COARSEBATTERYVOLTAGE_MASK); 63 | } 64 | 65 | void HeartRateBatteryStatusMsg::setBatteryStatus(uint8_t status) { 66 | set8BitValue(status, 67 | BATTERYSTATUS_BYTE, BATTERYSTATUS_MASK, BATTERYSTATUS_SHIFT); 68 | } 69 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/DataPages/ANTPLUS_BicycleSpeedBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define DATAPAGE_BYTE 0 6 | #define TOGGLE_BYTE 0 7 | #define BIKESPEEDEVENTTIME_LSB_BYTE 4 8 | #define BIKESPEEDEVENTTIME_MSB_BYTE 5 9 | #define CUMULATIVESPEEDREVOLUTIONCOUNT_LSB_BYTE 6 10 | #define CUMULATIVESPEEDREVOLUTIONCOUNT_MSB_BYTE 7 11 | #define DATAPAGE_MASK 0x7F 12 | #define TOGGLE_MASK 0x80 13 | #define TOGGLE_SHIFT 7 14 | 15 | template 16 | BicycleSpeedCoreMainDataPage::BicycleSpeedCoreMainDataPage() : 17 | CoreDataPage() {} 18 | 19 | template 20 | uint8_t BicycleSpeedCoreMainDataPage::getDataPageNumber() { 21 | return this->get8BitValue(DATAPAGE_BYTE, DATAPAGE_MASK); 22 | } 23 | 24 | template 25 | uint8_t BicycleSpeedCoreMainDataPage::getPageChangeToggle() { 26 | return this->get8BitValue(TOGGLE_BYTE, TOGGLE_MASK, TOGGLE_SHIFT); 27 | } 28 | 29 | template 30 | uint16_t BicycleSpeedCoreMainDataPage::getBikeSpeedEventTime() { 31 | return this->get16BitValue(BIKESPEEDEVENTTIME_LSB_BYTE, 32 | BIKESPEEDEVENTTIME_MSB_BYTE); 33 | } 34 | 35 | template 36 | uint16_t BicycleSpeedCoreMainDataPage::getCumulativeSpeedRevolutionCount() { 37 | return this->get16BitValue(CUMULATIVESPEEDREVOLUTIONCOUNT_LSB_BYTE, 38 | CUMULATIVESPEEDREVOLUTIONCOUNT_MSB_BYTE); 39 | } 40 | template class BicycleSpeedCoreMainDataPage; 41 | template class BicycleSpeedCoreMainDataPage; 42 | 43 | BicycleSpeedBaseMainDataPage::BicycleSpeedBaseMainDataPage(AntRxDataResponse& dp) : 44 | BaseDataPage(dp), 45 | BicycleSpeedCoreMainDataPage() {} 46 | 47 | BicycleSpeedBaseMainDataPageMsg::BicycleSpeedBaseMainDataPageMsg(uint8_t dataPageNumber) : 48 | BaseDataPageMsg(), 49 | BicycleSpeedCoreMainDataPage() { 50 | setDataBuffer(_buffer); 51 | set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 52 | } 53 | 54 | void BicycleSpeedBaseMainDataPageMsg::setPageChangeToggle(uint8_t toggle) { 55 | set8BitValue(toggle ? TOGGLE_MASK : 0, TOGGLE_BYTE, TOGGLE_MASK); 56 | } 57 | 58 | void BicycleSpeedBaseMainDataPageMsg::setBikeSpeedEventTime(uint16_t time) { 59 | set16BitValue(time, BIKESPEEDEVENTTIME_LSB_BYTE, 60 | BIKESPEEDEVENTTIME_MSB_BYTE); 61 | } 62 | 63 | void BicycleSpeedBaseMainDataPageMsg::setCumulativeSpeedRevolutionCount(uint16_t count) { 64 | set16BitValue(count, CUMULATIVESPEEDREVOLUTIONCOUNT_LSB_BYTE, 65 | CUMULATIVESPEEDREVOLUTIONCOUNT_MSB_BYTE); 66 | } 67 | -------------------------------------------------------------------------------- /src/Profiles/HeartRate/DataPages/ANTPLUS_HeartRateBaseMainDataPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define DATAPAGE_BYTE 0 6 | #define TOGGLE_BYTE 0 7 | #define HEARTBEATEVENTTIME_LSB_BYTE 4 8 | #define HEARTBEATEVENTTIME_MSB_BYTE 5 9 | #define HEARTBEATCOUNT_BYTE 6 10 | #define COMPUTEDHEARTRATE_BYTE 7 11 | #define DATAPAGE_MASK 0x7F 12 | #define TOGGLE_MASK 0x80 13 | #define TOGGLE_SHIFT 7 14 | 15 | template 16 | HeartRateCoreMainDataPage::HeartRateCoreMainDataPage() : CoreDataPage() {} 17 | 18 | template 19 | uint8_t HeartRateCoreMainDataPage::getDataPageNumber() { 20 | return this->get8BitValue(DATAPAGE_BYTE, DATAPAGE_MASK); 21 | } 22 | 23 | template 24 | uint8_t HeartRateCoreMainDataPage::getPageChangeToggle() { 25 | return this->get8BitValue(TOGGLE_BYTE, TOGGLE_MASK, TOGGLE_SHIFT); 26 | } 27 | 28 | template 29 | uint16_t HeartRateCoreMainDataPage::getHeartBeatEventTime() { 30 | return this->get16BitValue(HEARTBEATEVENTTIME_LSB_BYTE, HEARTBEATEVENTTIME_MSB_BYTE); 31 | } 32 | 33 | template 34 | uint8_t HeartRateCoreMainDataPage::getHeartBeatCount() { 35 | return this->get8BitValue(HEARTBEATCOUNT_BYTE); 36 | } 37 | 38 | template 39 | uint8_t HeartRateCoreMainDataPage::getComputedHeartRate() { 40 | return this->get8BitValue(COMPUTEDHEARTRATE_BYTE); 41 | } 42 | 43 | template class HeartRateCoreMainDataPage; 44 | template class HeartRateCoreMainDataPage; 45 | 46 | HeartRateBaseMainDataPage::HeartRateBaseMainDataPage(AntRxDataResponse& dp) : 47 | BaseDataPage(dp), 48 | HeartRateCoreMainDataPage() {} 49 | 50 | HeartRateBaseMainDataPageMsg::HeartRateBaseMainDataPageMsg(uint8_t dataPageNumber) : 51 | BaseDataPageMsg(), 52 | HeartRateCoreMainDataPage() { 53 | setDataBuffer(_buffer); 54 | set8BitValue(dataPageNumber, ANTPLUS_DEFAULT_DATAPAGE_BYTE); 55 | } 56 | 57 | void HeartRateBaseMainDataPageMsg::setPageChangeToggle(uint8_t toggle) { 58 | set8BitValue(toggle ? 1 : 0, TOGGLE_BYTE, TOGGLE_MASK, TOGGLE_SHIFT); 59 | } 60 | 61 | void HeartRateBaseMainDataPageMsg::setHeartBeatEventTime(uint16_t time) { 62 | set16BitValue(time, HEARTBEATEVENTTIME_LSB_BYTE, 63 | HEARTBEATEVENTTIME_MSB_BYTE); 64 | } 65 | 66 | void HeartRateBaseMainDataPageMsg::setHeartBeatCount(uint8_t count) { 67 | set8BitValue(count, HEARTBEATCOUNT_BYTE); 68 | } 69 | 70 | void HeartRateBaseMainDataPageMsg::setComputedHeartRate(uint8_t heartRate) { 71 | set8BitValue(heartRate, COMPUTEDHEARTRATE_BYTE); 72 | } 73 | -------------------------------------------------------------------------------- /src/CommonDataPages/ANTPLUS_CommonDataPageDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_COMMONDATAPAGEDEFINES_h 2 | #define ANTPLUS_COMMONDATAPAGEDEFINES_h 3 | 4 | /* Request Data Page */ 5 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_NUMBER 70 6 | 7 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_SLAVESERIALNUMBER_INVALID 0xFFFF 8 | 9 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_DESCRIPTORBYTE1_INVALID 0xFF 10 | 11 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_DESCRIPTORBYTE2_INVALID 0xFF 12 | 13 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_USEACKNOWLEDGED_TRUE 0x80 14 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_USEACKNOWLEDGED_INVALID 0 15 | 16 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_COMMANDTYPE_REQUESTDATAPAGE 1 17 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_COMMANDTYPE_REQUESTANTFSSESSION 2 18 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_COMMANDTYPE_REQUESTDATAPAGEFROMSLAVE 3 19 | #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_COMMANDTYPE_REQUESTDATAPAGESET 4 20 | 21 | 22 | /* Mode Settings */ 23 | #define ANTPLUS_COMMON_DATAPAGE_MODESETTINGS_NUMBER 76 24 | 25 | #define ANTPLUS_COMMON_DATAPAGE_MODESETTINGS_SPORTSMODE_RUNNING 1 26 | #define ANTPLUS_COMMON_DATAPAGE_MODESETTINGS_SPORTSMODE_CYCLING 2 27 | #define ANTPLUS_COMMON_DATAPAGE_MODESETTINGS_SPORTSMODE_SWIMMING 5 28 | 29 | 30 | /* Multi-Component Manufacturers Information */ 31 | #define ANTPLUS_COMMON_DATAPAGE_MULTICOMPONENTSYSTEMMANUFACTURERSINFORMATION_NUMBER 78 32 | 33 | 34 | /* Multi-Component Product Information */ 35 | #define ANTPLUS_COMMON_DATAPAGE_MULTICOMPONENTSYSTEMPRODUCTINFORMATION_NUMBER 79 36 | 37 | 38 | /* Manufacturers Information */ 39 | #define ANTPLUS_COMMON_DATAPAGE_MANUFACTURERSINFORMATION_NUMBER 80 40 | 41 | 42 | /* Product Information */ 43 | #define ANTPLUS_COMMON_DATAPAGE_PRODUCTINFORMATION_NUMBER 81 44 | 45 | #define ANTPLUS_COMMON_DATAPAGE_PRODUCTINFORMATION_SWREVISIONSUPPLEMENTAL_INVALID 0xFF 46 | 47 | 48 | /* Battery Status */ 49 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_NUMBER 82 50 | 51 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_NEW 1 52 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_GOOD 2 53 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_OK 3 54 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_LOW 4 55 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_CRITICAL 5 56 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_BATTERYSTATUS_INVALID 7 57 | 58 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_CUMULATIVEOPERATINGTIMERESOLUTION_16S 0 59 | #define ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_CUMULATIVEOPERATINGTIMERESOLUTION_2S 1 60 | 61 | #endif // ANTPLUS_COMMONDATAPAGEDEFINES_h 62 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecGeneralSettingsPage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define CYCLE_LENGTH_BYTE 3 5 | #define INCLINE_LSB_BYTE 4 6 | #define INCLINE_MSB_BYTE 5 7 | #define RESISTANTCE_LEVEL_BYTE 6 8 | 9 | template 10 | FecBaseGeneralSettingsPage::FecBaseGeneralSettingsPage() : 11 | CoreDataPage() {} 12 | 13 | template 14 | uint8_t FecBaseGeneralSettingsPage::getCycleLength() { 15 | return this->get8BitValue(CYCLE_LENGTH_BYTE); 16 | } 17 | 18 | template 19 | uint16_t FecBaseGeneralSettingsPage::getIncline() { 20 | return this->get16BitValue(INCLINE_LSB_BYTE, INCLINE_MSB_BYTE); 21 | } 22 | 23 | template 24 | uint8_t FecBaseGeneralSettingsPage::getResistanceLevel() { 25 | return this->get8BitValue(RESISTANTCE_LEVEL_BYTE); 26 | } 27 | 28 | template 29 | uint8_t FecBaseGeneralSettingsPage::getFeState() { 30 | return this->get8BitValue(FESTATE_BYTE, FESTATE_MASK, FESTATE_SHIFT); 31 | } 32 | 33 | template 34 | uint8_t FecBaseGeneralSettingsPage::getLapToggleBit() { 35 | return this->get8BitValue(LAPTOGGLEBIT_BYTE, LAPTOGGLEBIT_MASK, LAPTOGGLEBIT_SHIFT); 36 | } 37 | 38 | template class FecBaseGeneralSettingsPage; 39 | template class FecBaseGeneralSettingsPage; 40 | 41 | FecGeneralSettingsPage::FecGeneralSettingsPage(AntRxDataResponse& dp) : 42 | FecBaseMainDataPage(dp), 43 | FecBaseGeneralSettingsPage() {} 44 | 45 | FecGeneralSettingsPageMsg::FecGeneralSettingsPageMsg() : 46 | FecBaseMainDataPageMsg(ANTPLUS_FEC_DATAPAGE_GENERALSETTINGSPAGE_NUMBER), 47 | FecBaseGeneralSettingsPage() { 48 | setCycleLength(ANTPLUS_FEC_DATAPAGE_GENERALSETTINGSPAGE_CYCLELENGTH_INVALID); 49 | setIncline(ANTPLUS_FEC_DATAPAGE_GENERALSETTINGSPAGE_INCLINE_INVALID); 50 | setResistanceLevel(ANTPLUS_FEC_DATAPAGE_GENERALSETTINGSPAGE_RESISTANCELEVEL_INVALID); 51 | setFeState(ANTPLUS_FEC_DATAPAGE_FESTATE_INUSE); 52 | } 53 | 54 | void FecGeneralSettingsPageMsg::setCycleLength(uint8_t cycleLength) { 55 | set8BitValue(cycleLength, CYCLE_LENGTH_BYTE); 56 | } 57 | 58 | void FecGeneralSettingsPageMsg::setIncline(uint16_t incline) { 59 | set16BitValue(incline, INCLINE_LSB_BYTE, INCLINE_MSB_BYTE); 60 | } 61 | 62 | void FecGeneralSettingsPageMsg::setResistanceLevel(uint8_t resistanceLevel) { 63 | set8BitValue(resistanceLevel, RESISTANTCE_LEVEL_BYTE); 64 | } 65 | 66 | void FecGeneralSettingsPageMsg::setFeState(uint8_t state) { 67 | set8BitValue(state, FESTATE_BYTE, FESTATE_MASK, FESTATE_SHIFT); 68 | } 69 | 70 | void FecGeneralSettingsPageMsg::setLapToggleBit(uint8_t bit) { 71 | set8BitValue(bit, LAPTOGGLEBIT_BYTE, LAPTOGGLEBIT_MASK, LAPTOGGLEBIT_SHIFT); 72 | } 73 | -------------------------------------------------------------------------------- /src/Profiles/BicycleSpeed/Profiles/ANTPLUS_ProfileBicycleSpeedDisplay.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILEBICYCLESPEEDDISPLAY_h 2 | #define ANTPLUS_PROFILEBICYCLESPEEDDISPLAY_h 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class ProfileBicycleSpeedDisplay : public BaseSlaveProfile { 9 | public: 10 | ProfileBicycleSpeedDisplay(); 11 | explicit ProfileBicycleSpeedDisplay(uint16_t deviceNumber); 12 | explicit ProfileBicycleSpeedDisplay(uint16_t deviceNumber, uint8_t transmissionType); 13 | void onBicycleSpeedBatteryStatus(void (*func)(BicycleSpeedBatteryStatus&, uintptr_t), uintptr_t data = 0) { _onBicycleSpeedBatteryStatus.set(func, data); } 14 | void onBicycleSpeedCumulativeOperatingTime(void (*func)(BicycleSpeedCumulativeOperatingTime&, uintptr_t), uintptr_t data = 0) { _onBicycleSpeedCumulativeOperatingTime.set(func, data); } 15 | void onBicycleSpeedDefault(void (*func)(BicycleSpeedDefault&, uintptr_t), uintptr_t data = 0) { _onBicycleSpeedDefault.set(func, data); } 16 | void onBicycleSpeedManufacturerID(void (*func)(BicycleSpeedManufacturerID&, uintptr_t), uintptr_t data = 0) { _onBicycleSpeedManufacturerID.set(func, data); } 17 | void onBicycleSpeedMotionAndSpeed(void (*func)(BicycleSpeedMotionAndSpeed&, uintptr_t), uintptr_t data = 0) { _onBicycleSpeedMotionAndSpeed.set(func, data); } 18 | void onBicycleSpeedProductID(void (*func)(BicycleSpeedProductID&, uintptr_t), uintptr_t data = 0) { _onBicycleSpeedProductID.set(func, data); } 19 | 20 | private: 21 | void setChannelConfig(); 22 | void onBroadcastData(BroadcastData& msg) override; 23 | void onAcknowledgedData(AcknowledgedData& msg) override; 24 | 25 | bool handleDataPage(BicycleSpeedBaseMainDataPage& dataPage); 26 | bool handleBatteryStatus(BicycleSpeedBaseMainDataPage& dataPage); 27 | bool handleCumulativeOperatingTime(BicycleSpeedBaseMainDataPage& dataPage); 28 | bool handleDefault(BicycleSpeedBaseMainDataPage& dataPage); 29 | bool handleManufacturerID(BicycleSpeedBaseMainDataPage& dataPage); 30 | bool handleMotionAndSpeed(BicycleSpeedBaseMainDataPage& dataPage); 31 | bool handleProductID(BicycleSpeedBaseMainDataPage& dataPage); 32 | AntCallback _onBicycleSpeedBatteryStatus = { .func = NULL }; 33 | AntCallback _onBicycleSpeedCumulativeOperatingTime = { .func = NULL }; 34 | AntCallback _onBicycleSpeedDefault = { .func = NULL }; 35 | AntCallback _onBicycleSpeedManufacturerID = { .func = NULL }; 36 | AntCallback _onBicycleSpeedMotionAndSpeed = { .func = NULL }; 37 | AntCallback _onBicycleSpeedProductID = { .func = NULL }; 38 | }; 39 | 40 | #endif // ANTPLUS_PROFILEBICYCLESPEEDDISPLAY_h 41 | -------------------------------------------------------------------------------- /src/BaseClasses/ANTPLUS_BaseMasterProfile.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | BaseMasterProfile::BaseMasterProfile(uint16_t deviceNumber, uint8_t transmissionType) : BaseProfile(deviceNumber, transmissionType) { 7 | } 8 | 9 | void BaseMasterProfile::onChannelEventResponse(ChannelEventResponse& msg) { 10 | BaseProfile::onChannelEventResponse(msg); 11 | if (msg.getCode() == STATUS_EVENT_TX) { 12 | transmitNextDataPage(); 13 | } 14 | if (msg.getCode() == STATUS_EVENT_TRANSFER_TX_COMPLETED) { 15 | _requestAcked = true; 16 | } 17 | } 18 | 19 | void BaseMasterProfile::onAcknowledgedData(AcknowledgedData& msg) { 20 | BaseProfile::onAcknowledgedData(msg); 21 | BaseDataPage dp(msg); 22 | 23 | if (dp.getDataPageNumber() == ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_NUMBER) { 24 | handleRequestDataPage(msg); 25 | } 26 | } 27 | 28 | void BaseMasterProfile::handleRequestDataPage(AcknowledgedData& msg) { 29 | RequestDataPage dp(msg); 30 | if (!isDataPageValid(dp.getRequestedPageNumber())) { 31 | // Datapage requested isn't supported, don't do anything 32 | return; 33 | } 34 | _requestedCount = dp.getRequestedTransmissionResponseCount(); 35 | _requestedPage = dp.getRequestedPageNumber(); 36 | _isRequestAcknowledged = dp.getRequestedTransmissionUseAcknowledged(); 37 | _requestAcked = !dp.transmitTillAcknowledged(); 38 | // TODO handle command type 39 | } 40 | 41 | bool BaseMasterProfile::isRequestedPagePending() { 42 | return _requestedCount > 0 || !_requestAcked; 43 | } 44 | 45 | uint8_t BaseMasterProfile::getRequestedPage() { 46 | if (_requestedCount > 0) { 47 | _requestedCount--; 48 | } 49 | return _requestedPage; 50 | } 51 | 52 | bool BaseMasterProfile::isRequestedPageAcknowledged() { 53 | return _isRequestAcknowledged && _ackMessagesAllowed; 54 | } 55 | 56 | void BaseMasterProfile::begin() { 57 | BaseProfile::begin(); 58 | // send first datapage manually so we don't transmit 0s 59 | transmitNextDataPage(); 60 | } 61 | 62 | void BaseMasterProfile::invalidateDataPageRequest() { 63 | _requestedCount = 0; 64 | _requestAcked = true; 65 | } 66 | 67 | void BaseMasterProfile::setAckMessageUsage(bool on) { 68 | _ackMessagesAllowed = on; 69 | } 70 | 71 | void BaseMasterProfile::transmitMsg(BaseDataPageMsg &msg) { 72 | if (isRequestedPageAcknowledged() && isRequestedPagePending()) { 73 | AcknowledgedDataMsg ack; 74 | ack.setDataBuffer(msg.getDataBuffer()); 75 | send(ack); 76 | } else { 77 | send(msg); 78 | } 79 | } 80 | 81 | void BaseMasterProfile::transmitMsg(BaseDataPageMsg &msg) { 82 | send(msg); 83 | } 84 | -------------------------------------------------------------------------------- /src/Profiles/Shifting/ANTPLUS_ShiftingDefines.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_SHIFTINGPROFILEDEFINES_h 2 | #define ANTPLUS_SHIFTINGPROFILEDEFINES_h 3 | 4 | #define ANTPLUS_SHIFTING_DEVICETYPE 34 5 | 6 | /* Pages */ 7 | #define ANTPLUS_SHIFTING_DATAPAGE_SHIFTSYSTEMSTATUS_NUMBER 1 8 | 9 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_SYSTEM 0 10 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_FRONTDERAILLEUR 1 11 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_REARDERAILLEUR 2 12 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTSHIFTER 3 13 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTSHIFTER 4 14 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_SHIFTER 5 15 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTEXTENSIONSHIFTER 6 16 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTEXTENSIONSHIFTER 7 17 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_EXTENSIONSHIFTER1 8 18 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTEXTENSIONSHIFTER2 9 19 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTEXTENSIONSHIFTER2 10 20 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_EXTENSIONSHIFTER2 11 21 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_UNKNOWNIDENTIFIED 15 22 | 23 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_SYSTEM_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_SYSTEM) 24 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_FRONTDERAILLEUR_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_FRONTDERAILLEUR) 25 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_REARDERAILLEUR_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_REARDERAILLEUR) 26 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTSHIFTER_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTSHIFTER) 27 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTSHIFTER_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTSHIFTER) 28 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_SHIFTER_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_SHIFTER) 29 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTEXTENSIONSHIFTER_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTEXTENSIONSHIFTER) 30 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTEXTENSIONSHIFTER_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTEXTENSIONSHIFTER) 31 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_EXTENSIONSHIFTER1_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_EXTENSIONSHIFTER1) 32 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTEXTENSIONSHIFTER2_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_LEFTEXTENSIONSHIFTER2) 33 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTEXTENSIONSHIFTER2_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_RIGHTEXTENSIONSHIFTER2) 34 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_EXTENSIONSHIFTER2_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_EXTENSIONSHIFTER2) 35 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_UNKNOWNIDENTIFIED_FLAG (1 << ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_UNKNOWNIDENTIFIED) 36 | 37 | #define ANTPLUS_SHIFTING_COMPONENTIDENTIFIER_NOTUSED 0xFF 38 | 39 | #endif // ANTPLUS_SHIFTINGPROFILEDEFINES_h 40 | -------------------------------------------------------------------------------- /examples/DeviceSearch/DeviceSearch.ino: -------------------------------------------------------------------------------- 1 | /*********************************** 2 | * AntPlus DeviceSearch example 3 | * 4 | * The example demonstrates the device 5 | * search functionality of the router. 6 | * 7 | * Author Curtis Malainey 8 | ************************************/ 9 | #include 10 | #include "ANT.h" 11 | #include "ANTPLUS.h" 12 | 13 | #define BAUD_RATE 9600 14 | // 30s 15 | #define SEARCH_RUNTIME 30*1000 16 | 17 | const uint8_t NETWORK_KEY[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}; // get this from thisisant.com 18 | uint32_t timeLastSwitch = 0; 19 | bool isSearching = false; 20 | 21 | ArduinoSerialAntWithCallbacks ant; 22 | AntPlusRouter router; 23 | 24 | void searchCallback(uint16_t deviceNumber, uint8_t deviceType, uint8_t transmissionType, uint8_t rssi); 25 | void flipSearch(); 26 | 27 | void setup() { 28 | Serial.begin(BAUD_RATE); 29 | Serial.println("Running"); 30 | Serial1.begin(BAUD_RATE); 31 | ant.setSerial(Serial1); 32 | // Delay after initial setup to wait for user to connect on serial 33 | 34 | router.setDriver(&ant); // never touch ant again 35 | router.setAntPlusNetworkKey(NETWORK_KEY); 36 | flipSearch(); 37 | } 38 | 39 | void loop() { 40 | router.loop(); 41 | 42 | if (millis() - timeLastSwitch > SEARCH_RUNTIME) { 43 | timeLastSwitch = millis(); 44 | flipSearch(); 45 | } 46 | } 47 | 48 | void flipSearch() { 49 | Serial.println("==========================="); 50 | if (isSearching) { 51 | // starting a search will stop all profiles and will need to be 52 | // restarted after the search is stopped 53 | router.startRxSearch(searchCallback); 54 | } else { 55 | router.stopRxSearch(); 56 | } 57 | isSearching = !isSearching; 58 | } 59 | 60 | void searchCallback(uint16_t deviceNumber, uint8_t deviceType, uint8_t transmissionType, uint8_t rssi) { 61 | Serial.print("Device Number: "); 62 | Serial.print(deviceNumber); 63 | Serial.print(" Device Type: "); 64 | switch (deviceType) { 65 | case ANTPLUS_BICYCLEPOWER_DEVICETYPE: 66 | Serial.println("Bicycle Power"); 67 | break; 68 | case ANTPLUS_BICYCLESPEED_DEVICETYPE: 69 | Serial.println("Bicycle Speed"); 70 | break; 71 | case ANTPLUS_ENVIRONMENT_DEVICETYPE: 72 | Serial.println("Environment"); 73 | break; 74 | case ANTPLUS_FEC_REALTIMECHANNEL_DEVICETYPE: 75 | Serial.println("Realtime Fitness Equiment"); 76 | break; 77 | case ANTPLUS_HEARTRATE_DEVICETYPE: 78 | Serial.println("Heart Rate"); 79 | break; 80 | case ANTPLUS_LEV_DEVICETYPE: 81 | Serial.println("Light Electric Vehicle"); 82 | break; 83 | case ANTPLUS_MUSCLEOXYGEN_DEVICETYPE: 84 | Serial.println("Muscle Oxygen"); 85 | break; 86 | case ANTPLUS_SHIFTING_DEVICETYPE: 87 | Serial.println("Shifting"); 88 | break; 89 | default: 90 | Serial.println("Unknown"); 91 | break; 92 | } 93 | Serial.print(" Transmission Type: "); 94 | Serial.print(transmissionType); 95 | Serial.print(" RSSI: "); 96 | Serial.println(rssi); 97 | } 98 | -------------------------------------------------------------------------------- /src/Profiles/MuscleOxygen/Monitor/ANTPLUS_ProfileMuscleOxygenMonitor.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define MONITOR_CHANNELTYPE CHANNEL_TYPE_BIDIRECTIONAL_TRANSMIT 6 | #define MONITOR_TRANSMISSIONTYPE (TRANSMISSION_TYPE_INDEPENDENT | TRANSMISSION_TYPE_GLOBALDATAPGESUSED) 7 | 8 | ProfileMuscleOxygenMonitor::ProfileMuscleOxygenMonitor( uint16_t deviceNumber, uint8_t transmissionType, uint32_t flags) : 9 | BaseMasterProfile(deviceNumber, 10 | ANTPLUS_TRANSMISSION_SET_LSN( 11 | transmissionType, MONITOR_TRANSMISSIONTYPE)) 12 | { 13 | setChannelConfig(); 14 | // change the background cycle loop size 15 | _backgroundStepSize = 2 + ((flags & ANTPLUS_MUSCLEOXYGEN_FLAGS_BATTERYSTATUS_SUPPORTED) ? 1 : 0); 16 | } 17 | 18 | void ProfileMuscleOxygenMonitor::setChannelConfig() { 19 | setChannelType(MONITOR_CHANNELTYPE); 20 | setDeviceType(ANTPLUS_MUSCLEOXYGEN_DEVICETYPE); 21 | setChannelPeriod(MUSCLEOXYGEN_CHANNELPERIOD); 22 | setSearchTimeout(MUSCLEOXYGEN_SEARCHTIMEOUT); 23 | } 24 | 25 | bool ProfileMuscleOxygenMonitor::isDataPageValid(uint8_t dataPage) { 26 | switch (dataPage) { 27 | case ANTPLUS_MUSCLEOXYGEN_DATAPAGE_MUSCLEOXYGENDATA_NUMBER: 28 | case ANTPLUS_COMMON_DATAPAGE_PRODUCTINFORMATION_NUMBER: 29 | case ANTPLUS_COMMON_DATAPAGE_MANUFACTURERSINFORMATION_NUMBER: 30 | return true; 31 | case ANTPLUS_COMMON_DATAPAGE_BATTERYSTATUS_NUMBER: 32 | // TODO use callback 33 | return _flags & ANTPLUS_MUSCLEOXYGEN_FLAGS_BATTERYSTATUS_SUPPORTED; 34 | } 35 | return false; 36 | } 37 | 38 | void ProfileMuscleOxygenMonitor::transmitNextDataPage() { 39 | if (_patternStep++ < 64) { 40 | transmitMuscleOxygenMuscleOxygenDataMsg(); 41 | } 42 | else { 43 | if (++_backgroundStep == _backgroundStepSize) { 44 | _backgroundStep = 0; 45 | } 46 | if ((_backgroundStep % _backgroundStepSize) == 0) { 47 | transmitManufacturerInformationMsg(); 48 | } else if ((_backgroundStep % _backgroundStepSize) == 1) { 49 | transmitProductInformationMsg(); 50 | } else if (_flags & ANTPLUS_MUSCLEOXYGEN_FLAGS_BATTERYSTATUS_SUPPORTED) { 51 | transmitBatteryStatusMsg(); 52 | } 53 | _patternStep = 0; 54 | } 55 | } 56 | 57 | void ProfileMuscleOxygenMonitor::transmitManufacturerInformationMsg() { 58 | ManufacturersInformationMsg msg; 59 | _createManufacturersInformationMsg.call(msg); 60 | send(msg); 61 | } 62 | 63 | void ProfileMuscleOxygenMonitor::transmitProductInformationMsg() { 64 | ProductInformationMsg msg; 65 | _createProductInformationMsg.call(msg); 66 | send(msg); 67 | } 68 | 69 | void ProfileMuscleOxygenMonitor::transmitMuscleOxygenMuscleOxygenDataMsg() { 70 | MuscleOxygenMuscleOxygenDataMsg msg; 71 | _createMuscleOxygenMuscleOxygenDataMsg.call(msg); 72 | send(msg); 73 | } 74 | 75 | void ProfileMuscleOxygenMonitor::transmitBatteryStatusMsg() { 76 | BatteryStatusMsg msg; 77 | _createBatteryStatusMsg.call(msg); 78 | send(msg); 79 | } 80 | -------------------------------------------------------------------------------- /src/Profiles/Fec/DataPages/ANTPLUS_FecFeCapabilities.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define MAXIMUM_RESISTANCE_LSB_BYTE 5 5 | #define MAXIMUM_RESISTANCE_MSB_BYTE 6 6 | #define BASICRESISTANCEMODESUPPORT_BYTE 7 7 | #define BASICRESISTANCEMODESUPPORT_MASK 0x1 8 | #define TARGETPOWERMODESUPPORT_BYTE 7 9 | #define TARGETPOWERMODESUPPORT_MASK 0x2 10 | #define TARGETPOWERMODESUPPORT_SHIFT 1 11 | #define SIMULATIONMODESUPPORT_BYTE 7 12 | #define SIMULATIONMODESUPPORT_MASK 0x4 13 | #define SIMULATIONMODESUPPORT_SHIFT 2 14 | #define RESERVED_LSB_BYTE 1 15 | #define RESERVED_MSB_BYTE 4 16 | #define RESERVED_VALUE 0xFFFFFFFF 17 | 18 | template 19 | FecBaseFeCapabilities::FecBaseFeCapabilities() : 20 | CoreDataPage() {} 21 | 22 | template 23 | uint16_t FecBaseFeCapabilities::getMaximumResistance() { 24 | return this->get16BitValue(MAXIMUM_RESISTANCE_LSB_BYTE, MAXIMUM_RESISTANCE_MSB_BYTE); 25 | } 26 | 27 | template 28 | uint8_t FecBaseFeCapabilities::getBasicResistanceModeSupport() { 29 | return this->get8BitValue(BASICRESISTANCEMODESUPPORT_BYTE, BASICRESISTANCEMODESUPPORT_MASK); 30 | } 31 | 32 | template 33 | uint8_t FecBaseFeCapabilities::getTargetPowerModeSupport() { 34 | return this->get8BitValue(TARGETPOWERMODESUPPORT_BYTE, 35 | TARGETPOWERMODESUPPORT_MASK, 36 | TARGETPOWERMODESUPPORT_SHIFT); 37 | } 38 | 39 | template 40 | uint8_t FecBaseFeCapabilities::getSimulationModeSupport() { 41 | return this->get8BitValue(SIMULATIONMODESUPPORT_BYTE, 42 | SIMULATIONMODESUPPORT_MASK, 43 | SIMULATIONMODESUPPORT_SHIFT); 44 | } 45 | 46 | template class FecBaseFeCapabilities; 47 | template class FecBaseFeCapabilities; 48 | 49 | FecFeCapabilities::FecFeCapabilities(AntRxDataResponse& dp) : 50 | FecBaseMainDataPage(dp), 51 | FecBaseFeCapabilities() {} 52 | 53 | FecFeCapabilitiesMsg::FecFeCapabilitiesMsg() : 54 | FecBaseMainDataPageMsg(ANTPLUS_FEC_DATAPAGE_FECAPABILITIES_NUMBER), 55 | FecBaseFeCapabilities() { 56 | this->set32BitValue(RESERVED_VALUE, RESERVED_LSB_BYTE, RESERVED_MSB_BYTE); 57 | setMaximumResistance(ANTPLUS_FEC_DATAPAGE_FECAPABILITIES_MAXIMUM_RESISTANCE_INVALID); 58 | } 59 | 60 | void FecFeCapabilitiesMsg::setMaximumResistance(uint16_t maximumResistance) { 61 | set16BitValue(maximumResistance, MAXIMUM_RESISTANCE_LSB_BYTE, MAXIMUM_RESISTANCE_MSB_BYTE); 62 | } 63 | 64 | void FecFeCapabilitiesMsg::setBasicResistanceModeSupport(uint8_t support) { 65 | set8BitValue(support, BASICRESISTANCEMODESUPPORT_BYTE, BASICRESISTANCEMODESUPPORT_MASK); 66 | } 67 | 68 | void FecFeCapabilitiesMsg::setTargetPowerModeSupport(uint8_t support) { 69 | set8BitValue(support, 70 | TARGETPOWERMODESUPPORT_BYTE, 71 | TARGETPOWERMODESUPPORT_MASK, 72 | TARGETPOWERMODESUPPORT_SHIFT); 73 | } 74 | 75 | void FecFeCapabilitiesMsg::setSimulationModeSupport(uint8_t support) { 76 | set8BitValue(support, 77 | SIMULATIONMODESUPPORT_BYTE, 78 | SIMULATIONMODESUPPORT_MASK, 79 | SIMULATIONMODESUPPORT_SHIFT); 80 | } 81 | -------------------------------------------------------------------------------- /src/Profiles/Lev/Profiles/ANTPLUS_ProfileLevDisplay.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTPLUS_PROFILELEVDISPLAY_h 2 | #define ANTPLUS_PROFILELEVDISPLAY_h 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class ProfileLevDisplay : public BaseSlaveProfile { 9 | public: 10 | explicit ProfileLevDisplay(uint16_t deviceNumber = 0, uint8_t transmissionType = 0); 11 | 12 | void onLevSpeedSystemInformation1(void(*func)(LevSpeedSystemInformation1&, uintptr_t), uintptr_t data = 0) { _onLevSpeedSystemInformation1.set(func, data); } 13 | void onLevSpeedDistanceInformation(void(*func)(LevSpeedDistanceInformation&, uintptr_t), uintptr_t data = 0) { _onLevSpeedDistanceInformation.set(func, data); } 14 | void onLevAltSpeedDistanceInformation(void(*func)(LevAltSpeedDistanceInformation&, uintptr_t), uintptr_t data = 0) { _onLevAltSpeedDistanceInformation.set(func, data); } 15 | void onLevSpeedSystemInformation2(void(*func)(LevSpeedSystemInformation2&, uintptr_t), uintptr_t data = 0) { _onLevSpeedSystemInformation2.set(func, data); } 16 | void onLevBatteryInformation(void(*func)(LevBatteryInformation&, uintptr_t), uintptr_t data = 0) { _onLevBatteryInformation.set(func, data); } 17 | void onLevCapabilities(void(*func)(LevCapabilities&, uintptr_t), uintptr_t data = 0) { _onLevCapabilities.set(func, data); } 18 | void onManufacturersInformation(void(*func)(ManufacturersInformation&, uintptr_t), uintptr_t data = 0) { _onManufacturersInformation.set(func, data); } 19 | void onProductInformation(void(*func)(ProductInformation&, uintptr_t), uintptr_t data = 0) { _onProductInformation.set(func, data); } 20 | 21 | private: 22 | void setChannelConfig(); 23 | void onBroadcastData(BroadcastData& msg) override; 24 | void onAcknowledgedData(AcknowledgedData& msg) override; 25 | 26 | bool handleDataPage(LevBaseMainDataPage& dataPage); 27 | bool handleSpeedSystemInformation1(LevBaseMainDataPage& dataPage); 28 | bool handleSpeedDistanceInformation(LevBaseMainDataPage& dataPage); 29 | bool handleAltSpeedDistanceInformation(LevBaseMainDataPage& dataPage); 30 | bool handleSpeedSystemInformation2(LevBaseMainDataPage& dataPage); 31 | bool handleBatteryInformation(LevBaseMainDataPage& dataPage); 32 | bool handleCapabilities(LevBaseMainDataPage& dataPage); 33 | bool handleManufacturersInformation(LevBaseMainDataPage& dataPage); 34 | bool handleProductInformation(LevBaseMainDataPage& dataPage); 35 | 36 | AntCallback _onLevSpeedSystemInformation1 = { .func = NULL }; 37 | AntCallback _onLevSpeedDistanceInformation = { .func = NULL }; 38 | AntCallback _onLevAltSpeedDistanceInformation = { .func = NULL }; 39 | AntCallback _onLevSpeedSystemInformation2 = { .func = NULL }; 40 | AntCallback _onLevBatteryInformation = { .func = NULL }; 41 | AntCallback _onLevCapabilities = { .func = NULL }; 42 | AntCallback _onManufacturersInformation = { .func = NULL }; 43 | AntCallback _onProductInformation = { .func = NULL }; 44 | }; 45 | 46 | #endif // ANTPLUS_PROFILELEVDISPLAY_h 47 | --------------------------------------------------------------------------------