Speed and Cadence Profile

Author: Tapasztó Lejla

libAnt/core.py

@@ -0,0 +1,10 @@
+def lazyproperty(fn):
+    attr_name = '__' + fn.__name__
+
+    @property
+    def _lazyprop(self):
+        if not hasattr(self, attr_name):
+            setattr(self, attr_name, fn(self))
+        return getattr(self, attr_name)
+
+    return _lazyprop

libAnt/message.py

@@ -41,7 +41,11 @@ def __init__(self, type: int, content: bytes):
         self.flag = None
         self.deviceNumber = self.deviceType = self.transType = None
         self.rssiMeasurementType = self.rssi = self._rssiThreshold = None
+        self.rssi = None
+        self.rssiThreshold = None
         self.rxTimestamp = None
+        self.channel = None
+        self.extendedContent = None
 
         super().__init__(type, content)
 
@@ -59,14 +63,14 @@ def build(self, raw: bytes):
                 self.transType = self.extendedContent[3]
                 offset += 4
             if self.flag & EXT_FLAG_RSSI:
-                rssi = self.extendedContent[offset:(offset+3)]
+                rssi = self.extendedContent[offset:(offset + 3)]
                 self.rssiMeasurementType = rssi[0]
                 self.rssi = rssi[1]
                 self.rssiThreshold = rssi[2]
                 offset += 3
             if self.flag & EXT_FLAG_TIMESTAMP:
                 self.rxTimestamp = int.from_bytes(self.extendedContent[offset:],
-                                                   byteorder='little', signed=False)
+                                                  byteorder='little', signed=False)
         return self
 
     def checksum(self) -> int:
@@ -121,6 +125,7 @@ def __init__(self, enable: bool = True):
         content = bytes([0, int(enable)])
         super().__init__(MESSAGE_ENABLE_EXT_RX_MESSAGES, content)
 
+
 class LibConfigMessage(Message):
     def __init__(self, rxTimestamp: bool = True, rssi: bool = True, channelId: bool = True):
         config = 0
@@ -130,4 +135,4 @@ def __init__(self, rxTimestamp: bool = True, rssi: bool = True, channelId: bool
             config |= EXT_FLAG_RSSI
         if channelId:
             config |= EXT_FLAG_CHANNEL_ID
-        super().__init__(MESSAGE_LIB_CONFIG, bytes([0, config]))
+        super().__init__(MESSAGE_LIB_CONFIG, bytes([0, config]))

libAnt/profiles/speed_cadence_profile.py

@@ -1,3 +1,4 @@
+from libAnt.core import lazyproperty
 from libAnt.profiles.factory import ProfileMessage
 
 
@@ -11,41 +12,41 @@ def __init__(self, msg, previous, staleSpeedCounter, staleCadenceCounter):
 
         if self.previous is not None:
             if self.speedEventTime == self.previous.speedEventTime:
-                self.staleSpeedCount[0] += 1
+                self.staleSpeedCounter[0] += 1
             else:
-                self.staleSpeedCount[0] = 0
+                self.staleSpeedCounter[0] = 0
 
             if self.cadenceEventTime == self.previous.cadenceEventTime:
-                self.staleCadenceCount[0] += 1
+                self.staleCadenceCounter[0] += 1
             else:
-                self.staleCadenceCount[0] = 0
+                self.staleCadenceCounter[0] = 0
 
     maxCadenceEventTime = 65536
     maxSpeedEventTime = 65536
     maxSpeedRevCount = 65536
     maxCadenceRevCount = 65536
-    maxStaleSpeedCount = 7
-    maxStaleCadenceCount = 7
+    maxstaleSpeedCounter = 7
+    maxstaleCadenceCounter = 7
 
     @lazyproperty
     def cadenceEventTime(self):
         """ Represents the time of the last valid bike cadence event (1/1024 sec) """
-        return (self.raw[2] << 8) | self.raw[1]
+        return (self.msg.content[1] << 8) | self.msg.content[0]
 
     @lazyproperty
     def cumulativeCadenceRevolutionCount(self):
         """ Represents the total number of pedal revolutions """
-        return (self.raw[4] << 8) | self.raw[3]
+        return (self.msg.content[3] << 8) | self.msg.content[2]
 
     @lazyproperty
     def speedEventTime(self):
         """ Represents the time of the last valid bike speed event (1/1024 sec) """
-        return (self.raw[6] << 8) | self.raw[5]
+        return (self.msg.content[5] << 8) | self.msg.content[4]
 
     @lazyproperty
     def cumulativeSpeedRevolutionCount(self):
         """ Represents the total number of wheel revolutions """
-        return (self.raw[8] << 8) | self.raw[7]
+        return (self.msg.content[7] << 8) | self.msg.content[6]
 
     @lazyproperty
     def speedEventTimeDiff(self):
@@ -97,7 +98,7 @@ def speed(self, c):
         if self.previous is None:
             return 0
         if self.speedEventTime == self.previous.speedEventTime:
-            if self.staleSpeedCount[0] > self.maxStaleSpeedCount:
+            if self.staleSpeedCounter[0] > self.maxstaleSpeedCounter:
                 return 0
             return self.previous.speed(c)
         return self.speedRevCountDiff * 1.024 * c / self.speedEventTimeDiff
@@ -110,7 +111,7 @@ def cadence(self):
         if self.previous is None:
             return 0
         if self.cadenceEventTime == self.previous.cadenceEventTime:
-            if self.staleCadenceCount[0] > self.maxStaleCadenceCount:
+            if self.staleCadenceCounter[0] > self.maxstaleCadenceCounter:
                 return 0
             return self.previous.cadence
         return self.cadenceRevCountDiff * 1024 * 60 / self.cadenceEventTimeDiff