Merge branch 'profiles/heart-rate/monitor' into develop

Author: cujomalainey

.travis.yml

@@ -34,9 +34,10 @@ cache:
  - "~/.platformio"
 
 env:
+ - PLATFORMIO_CI_SRC=examples/BicycleSpeedDisplay/BicycleSpeedDisplay.ino
  - PLATFORMIO_CI_SRC=examples/EnvironmentDisplay/EnvironmentDisplay.ino
  - PLATFORMIO_CI_SRC=examples/HeartRateDisplay/HeartRateDisplay.ino
- - PLATFORMIO_CI_SRC=examples/BicycleSpeedDisplay/BicycleSpeedDisplay.ino
+ - PLATFORMIO_CI_SRC=examples/HeartRateMonitor/HeartRateMonitor.ino
  - PLATFORMIO_CI_SRC=examples/LEVDisplay/LEVDisplay.ino
 
 install:

examples/HeartRateMonitor/HeartRateMonitor.ino

@@ -0,0 +1,122 @@
+/***********************************
+ * AntPlus HRMonitor example
+ *
+ * Implements a HR Monitor sensor with
+ * mocked data to it and then reports
+ * all events through the serial port
+ *
+ * Author Curtis Malainey
+ ************************************/
+#include <Arduino.h>
+#include "ANT.h"
+#include "ANTPLUS.h"
+
+#define BAUD_RATE 9600
+#define CHANNEL_0 0
+
+const uint8_t NETWORK_KEY[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}; // get this from thisisant.com
+
+AntWithCallbacks ant;
+AntPlusRouter router;
+ProfileHeartRateMonitor hr(123, 0);
+
+void batteryStatusDataPageHandler(HeartRateBatteryStatusMsg& msg, uintptr_t data);
+void capabilitiesDataPageHandler(HeartRateCapabilitiesMsg& msg, uintptr_t data);
+void cumulativeOperatingTimeDataPageHandler(HeartRateCumulativeOperatingTimeMsg& msg, uintptr_t data);
+void defaultDataPageHandler(HeartRateDefaultMsg& msg, uintptr_t data);
+void manufacturerInformationDataPageHandler(HeartRateManufacturerInformationMsg& msg, uintptr_t data);
+void previousHeartBeatDataPageHandler(HeartRatePreviousHeartBeatMsg& msg, uintptr_t data);
+void productInformationDataPageHandler(HeartRateProductInformationMsg& msg, uintptr_t data);
+void swimIntervalSummary(HeartRateSwimIntervalSummaryMsg& msg, uintptr_t data);
+
+void heartRateFeatures(uint8_t bitfield);
+void printStatus(uint8_t status);
+
+void setup() {
+ Serial1.begin(BAUD_RATE);
+ ant.setSerial(Serial1);
+ delay(15000);
+
+ router.setDriver(&ant); // never touch ant again
+ router.setAntPlusNetworkKey(NETWORK_KEY);
+ router.setProfile(CHANNEL_0, &hr);
+ // Delay after initial setup to wait for user to connect on serial
+
+ Serial.begin(BAUD_RATE);
+ Serial.println("Running");
+ hr.createHeartRateBatteryStatusMsg(batteryStatusDataPageHandler);
+ hr.createHeartRateCapabilitiesMsg(capabilitiesDataPageHandler);
+ hr.createHeartRateCumulativeOperatingTimeMsg(cumulativeOperatingTimeDataPageHandler);
+ hr.createHeartRateDefaultMsg(defaultDataPageHandler);
+ hr.createHeartRateManufacturerInformationMsg(manufacturerInformationDataPageHandler);
+ hr.createHeartRatePreviousHeartBeatMsg(previousHeartBeatDataPageHandler);
+ hr.createHeartRateProductInformationMsg(productInformationDataPageHandler);
+ hr.createHeartRateSwimIntervalSummaryMsg(swimIntervalSummary);
+ hr.begin();
+ // print channel status
+ Serial.println("===========================");
+ /* printStatus(status); */
+}
+
+void loop() {
+ // Call this very frequently
+ router.loop();
+}
+
+void printDpMsg(int dp, const char* s) {
+ Serial.print("Sending DataPage: ");
+ Serial.print(dp);
+ Serial.print(" - ");
+ Serial.println(s);
+}
+
+void batteryStatusDataPageHandler(HeartRateBatteryStatusMsg& msg, uintptr_t data) {
+ printDpMsg(7, "Battery Status");
+}
+
+void capabilitiesDataPageHandler(HeartRateCapabilitiesMsg& msg, uintptr_t data) {
+ printDpMsg(6, "Capabilities");
+}
+
+void cumulativeOperatingTimeDataPageHandler(HeartRateCumulativeOperatingTimeMsg& msg, uintptr_t data) {
+ printDpMsg(1, "Cumulative Operating Time");
+}
+
+void defaultDataPageHandler(HeartRateDefaultMsg& msg, uintptr_t data) {
+ // All fields are reserved
+ printDpMsg(0, "Default");
+}
+
+void manufacturerInformationDataPageHandler(HeartRateManufacturerInformationMsg& msg, uintptr_t data) {
+ printDpMsg(2, "Manufacturer Information");
+}
+
+void previousHeartBeatDataPageHandler(HeartRatePreviousHeartBeatMsg& dp, uintptr_t data) {
+ printDpMsg(4, "Previous Heart Beat");
+}
+
+void productInformationDataPageHandler(HeartRateProductInformationMsg& msg, uintptr_t data) {
+ printDpMsg(3, "Product Information");
+}
+
+void swimIntervalSummary(HeartRateSwimIntervalSummaryMsg& msg, uintptr_t data) {
+ printDpMsg(5, "Swim Interval");
+}
+
+void printStatus(uint8_t status) {
+ Serial.print("Channel Status: ");
+ switch (status) {
+ case CHANNEL_STATUS_UNASSIGNED:
+ Serial.println("Unassigned");
+ break;
+ case CHANNEL_STATUS_ASSIGNED:
+ Serial.println("Assigned");
+ break;
+ case CHANNEL_STATUS_SEARCHING:
+ Serial.println("Searching");
+ break;
+ case CHANNEL_STATUS_TRACKING:
+ Serial.println("Tracking");
+ break;
+ }
+}

src/BaseClasses/ANTPLUS_BaseMasterProfile.cpp

@@ -1,12 +1,50 @@
 #include <BaseClasses/ANTPLUS_BaseMasterProfile.h>
+#include <BaseClasses/ANTPLUS_BaseDataPage.h>
+#include <CommonDataPages/ANTPLUS_CommonDataPagePrivateDefines.h>
+#include <CommonDataPages/RX/ANTPLUS_RequestDataPage.h>
 
 BaseMasterProfile::BaseMasterProfile(uint16_t deviceNumber, uint8_t transmissionType) : BaseProfile(deviceNumber, transmissionType) {
-
 }
 
 void BaseMasterProfile::onChannelEventResponse(ChannelEventResponse& msg) {
+ BaseProfile::onChannelEventResponse(msg);
  if (msg.getCode() == STATUS_EVENT_TX) {
  transmitNextDataPage();
  }
- BaseProfile::onChannelEventResponse(msg);
-}
+ if (msg.getCode() == STATUS_EVENT_TRANSFER_TX_COMPLETED) {
+ _requestAcked = true;
+ }
+}
+
+void BaseMasterProfile::onAcknowledgedData(AcknowledgedData& msg) {
+ BaseProfile::onAcknowledgedData(msg);
+ BaseDataPage<AcknowledgedData> dp(msg);
+ if (dp.getDataPageNumber() == ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_NUMBER) {
+ handleRequestDataPage(msg);
+ }
+}
+
+void BaseMasterProfile::handleRequestDataPage(AcknowledgedData& msg) {
+ RequestDataPage dp(msg);
+ if (!isDataPageValid(dp.getRequestedPageNumber())) {
+ // Datapage requested isn't supported, don't do anything
+ return;
+ }
+ _requestedCount = dp.getRequestedPageCount();
+ _requestedPage = dp.getRequestedPageNumber();
+ _isRequestAcknowledged = dp.getUseAcknowledgedMsgs();
+ _requestAcked = !dp.transmitTillAcknowledged();
+}
+
+bool BaseMasterProfile::isRequestedPagePending() {
+ return _requestedCount > 0 || !_requestAcked;
+}
+
+uint8_t BaseMasterProfile::getRequestedPage() {
+ _requestedCount--;
+ return _requestedPage;
+}
+
+bool BaseMasterProfile::isRequestedPageAcknowledged() {
+ return _isRequestAcknowledged;
+}

src/BaseClasses/ANTPLUS_BaseMasterProfile.h

@@ -9,12 +9,39 @@ class BaseMasterProfile : public BaseProfile {
 protected:
  /**
  * Used to catch EVENT_TX and continue transmission pattern
+ * Also handles EVENT_TRANSFER_TX_COMPLETED for acknowledgement
  */
  virtual void onChannelEventResponse(ChannelEventResponse& msg);
  /**
  * This function, when called, will transmit the next message in the broadcast pattern
  */
  virtual void transmitNextDataPage() = 0;
+ /**
+ * Checks for RequestDataPage messages and handles them accordingly
+ */
+ virtual void onAcknowledgedData(AcknowledgedData& msg);
+ /**
+ * Checks with subclass to see if request is valid
+ */
+ virtual bool isDataPageValid(uint8_t dataPage) = 0;
+ /**
+ * returns true if pattern is currently interrupted by a request
+ */
+ bool isRequestedPagePending();
+ /**
+ * Returns the page number of the pending datapage
+ */
+ uint8_t getRequestedPage();
+ /**
+ * returns true if the request is meant to be sent as a acknowledged message
+ */
+ bool isRequestedPageAcknowledged();
+private:
+ void handleRequestDataPage(AcknowledgedData& msg);
+ uint8_t _requestedPage;
+ uint8_t _requestedCount = 0;
+ bool _isRequestAcknowledged;
+ bool _requestAcked = true;
 };
 
 #endif // ANTPLUS_BASESLAVEPROFILE_h

src/BaseClasses/ANTPLUS_BaseProfile.cpp

@@ -47,11 +47,11 @@ void BaseProfile::setChannelPeriod(uint16_t channelPeriod) {
 }
 
 void BaseProfile::pushChannelConfig() {
- AssignChannel ac = AssignChannel(_channel, _channelType, ANTPLUS_NETWORKKEY_INDEX);
- ChannelId ci = ChannelId(_channel, _deviceNumber, _deviceType, ANTPLUS_PAIRING_BIT_MASK & _deviceType, _transmissionType);
- ChannelPeriod cp = ChannelPeriod(_channel, _channelPeriod);
- ChannelRfFrequency crf = ChannelRfFrequency(_channel, ANTPLUS_CHANNEL_FREQUENCY);
- SearchTimeout st = SearchTimeout(_channel, _searchTimeout);
+ AssignChannel ac(_channel, _channelType, ANTPLUS_NETWORKKEY_INDEX);
+ ChannelId ci(_channel, _deviceNumber, _deviceType, ANTPLUS_PAIRING_BIT_MASK & _deviceType, _transmissionType);
+ ChannelPeriod cp(_channel, _channelPeriod);
+ ChannelRfFrequency crf(_channel, ANTPLUS_CHANNEL_FREQUENCY);
+ SearchTimeout st(_channel, _searchTimeout);
 
  _router->send(ac);
  _router->send(ci);
@@ -61,20 +61,21 @@ void BaseProfile::pushChannelConfig() {
 }
 
 void BaseProfile::openChannel() {
- OpenChannel oc = OpenChannel(_channel);
+ OpenChannel oc(_channel);
  _channelStatus = CHANNEL_STATUS_SEARCHING;
  _router->send(oc);
 }
 
 void BaseProfile::closeChannel() {
- CloseChannel cc = CloseChannel(_channel);
+ CloseChannel cc(_channel);
  _channelStatus = CHANNEL_STATUS_ASSIGNED;
  _router->send(cc);
 }
 
 void BaseProfile::onChannelEventResponse(ChannelEventResponse& msg) {
  uint8_t event = msg.getCode();
 
+ // TODO this looks weird to me
  switch (event) {
  case STATUS_EVENT_CHANNEL_CLOSED:
  case STATUS_EVENT_RX_FAIL_GO_TO_SEARCH:
@@ -117,15 +118,25 @@ void BaseProfile::onChannelStatus(ChannelStatus& msg) {
 
 void BaseProfile::checkProfileStatus() {
  if (!getDeviceNumber() || !getTransmissionType()) {
- RequestMessage rm = RequestMessage(CHANNEL_ID, _channel);
+ RequestMessage rm(CHANNEL_ID, _channel);
  send(rm);
  }
  if (_channelStatus == CHANNEL_STATUS_SEARCHING) {
- RequestMessage rm = RequestMessage(CHANNEL_STATUS, _channel);
+ RequestMessage rm(CHANNEL_STATUS, _channel);
  send(rm);
  }
 }
 
+void BaseProfile::send(AcknowledgedDataMsg& msg) {
+ msg.setChannelNumber(_channel);
+ _router->send(msg);
+}
+
+void BaseProfile::send(BroadcastDataMsg& msg) {
+ msg.setChannel(_channel);
+ _router->send(msg);
+}
+
 void BaseProfile::send(AntRequest& msg) {
  _router->send(msg);
 }

src/BaseClasses/ANTPLUS_BaseProfile.h

@@ -60,11 +60,18 @@ class BaseProfile {
  * Close radio channel and stop transmitting
  */
  virtual void stop();
+ /**
+ * Sends a message and sets the associated channel in the message
+ */
+ void send(AcknowledgedDataMsg& msg);
+ /**
+ * Sends a message and sets the associated channel in the message
+ */
+ void send(BroadcastDataMsg& msg);
  /**
  * Sends a message through the connected router
  */
  void send(AntRequest& msg);
-
 protected:
  void callOnOtherDataPage(AntRxDataResponse& msg);
  void setChannelType(uint8_t channelType);

src/CommonDataPages/ANTPLUS_CommonDataPagePrivateDefines.h

@@ -15,6 +15,9 @@
 #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_BYTE 5
 #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_COUNT_MASK 0x7FF
 #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_USEACKNOWLEDGED_MASK 0x80
+#define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_TRANSMISSIONCOUNT_MASK 0x7F
+#define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_TRANSMITTILLACKNOWLEDGED_VALUE 0x80
+#define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_USEACKNOWLEDGED_SHIFT 7
 
 #define ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDPAGENUMBER_BYTE 6
 

src/CommonDataPages/RX/ANTPLUS_RequestDataPage.cpp

@@ -17,8 +17,16 @@ uint8_t RequestDataPage::getDescriptorByte2() {
  return getData(ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_DESCRIPTORBYTE2_BYTE);
 }
 
-uint8_t RequestDataPage::getRequestedTransmissionResponse() {
- return getData(ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_BYTE);
+uint8_t RequestDataPage::getRequestedPageCount() {
+ return getData(ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_BYTE) & ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_TRANSMISSIONCOUNT_MASK;
+}
+
+uint8_t RequestDataPage::getUseAcknowledgedMsgs() {
+ return getData(ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_BYTE) >> ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_USEACKNOWLEDGED_SHIFT;
+}
+
+uint8_t RequestDataPage::transmitTillAcknowledged() {
+ return getData(ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_BYTE) == ANTPLUS_COMMON_DATAPAGE_REQUESTDATAPAGE_REQUESTEDTRANSMISSIONRESPONSE_TRANSMITTILLACKNOWLEDGED_VALUE;
 }
 
 uint8_t RequestDataPage::getRequestedPageNumber() {

src/CommonDataPages/RX/ANTPLUS_RequestDataPage.h

@@ -13,9 +13,11 @@ class RequestDataPage : public BaseDataPage<AcknowledgedData> {
  uint16_t getSlaveSerialNumber();
  uint8_t getDescriptorByte1();
  uint8_t getDescriptorByte2();
- uint8_t getRequestedTransmissionResponse();
+ uint8_t getRequestedPageCount();
+ uint8_t getUseAcknowledgedMsgs();
+ uint8_t transmitTillAcknowledged();
  uint8_t getRequestedPageNumber();
  uint8_t getCommandType();
 };
 
-#endif // ANTPLUS_REQUESTDATAPAGE_h
+#endif // ANTPLUS_REQUESTDATAPAGE_h