Made changes suggested by @dhalbert

Author: evaherrada

CircuitPython_Pyloton/code.py

@@ -8,15 +8,16 @@
 
 display = board.DISPLAY
 
+CONNECTION_TIMEOUT = 45
 
-heart = True
-speed = True
-cad = True
-ams = True
-debug = False
+HEART = True
+SPEED = True
+CAD = True
+AMS = True
+DEBUG = False
 
 # 84.229 is wheel circumference (700x23 in my case)
-pyloton = pyloton.Pyloton(ble, display, 84.229, heart, speed, cad, ams, debug)
+pyloton = pyloton.Pyloton(ble, display, 84.229, HEART, SPEED, CAD, AMS, DEBUG)
 
 pyloton.show_splash()
 
@@ -28,30 +29,34 @@
 speed_cad_connections = []
 radio = None
 while True:
-    if heart:
+    if HEART:
         if not hr_connection:
-            print("Running hr_connection")
+            print("Attempting to connect to a heart rate monitor")
             hr_connection = pyloton.heart_connect()
             ble.stop_scan()
-    if speed or cad:
+    if SPEED or CAD:
         if not speed_cad_connections:
-            print("Running speed_cad_connection")
+            print("Attempting to connect to speed and cadence monitors")
             speed_cad_connections = pyloton.speed_cad_connect()
 
-    if time()-start >= 45:
+    if time()-start >= CONNECTION_TIMEOUT:
         pyloton.timeout()
         break
     # Stop scanning whether or not we are connected.
     ble.stop_scan()
 
     # You may need to remove some parts of the following 2 lines depending on what
     # devices you are using.
+    # For example, remove hr_connection and hr_connection.connected if you aren't using a heart
+    # rate monitor. Do the same for other sensors you aren't using.
     if hr_connection and speed_cad_connections and ams:
         if hr_connection.connected and speed_cad_connections[0].connected and ams.connected:
             pyloton.setup_display()
             break
 
 # You may need to remove some parts of the following line depending on what devices you are using.
+# For example, remove hr_connection and hr_connection.connected if you aren't using a heart rate
+# monitor. Do the same for other sensors you aren't using.
 while hr_connection.connected and speed_cad_connections[0].connected and ams.connected:
     pyloton.update_display()
     pyloton.ams_remote()

CircuitPython_Pyloton/pyloton.py

@@ -84,45 +84,15 @@ class Pyloton:
     """
     Contains the various functions necessary for doing the Pyloton learn guide.
     """
-    # pylint: disable=too-many-instance-attributes
-    _previous_wheel = 0
-    _previous_crank = 0
-    _previous_revolutions = 0
-    _previous_rev = 0
-    _previous_speed = 0
-    _previous_cadence = 0
-    _previous_heart = 0
-    _i = 0
-    _j = 0
-    _setup = 0
-    _hr_label = None
-    _sp_label = None
-    _cad_label = None
-    _ams_label = None
-    _hr_service = None
-    _heart_y = None
-    _speed_y = None
-    _cad_y = None
-    _ams_y = None
-
-    ams = None
-    cyc_connections = None
-    cyc_services = None
-
-    splash = displayio.Group(max_size=25)
-    loading_group = displayio.Group()
+    #pylint: disable=too-many-instance-attributes
 
     YELLOW = 0xFCFF00
     PURPLE = 0x64337E
     WHITE = 0xFFFFFF
 
-    start = time.time()
-
-    track_artist = True
-
     clue = Clue()
 
-    def __init__(self, ble, display, circ, heart=True, speed=True, cad=True, ams=True, debug=False):
+    def __init__(self, ble, display, circ, heart=True, speed=True, cad=True, ams=True, debug=False): #pylint: disable=too-many-arguments
         self.debug = debug
 
         self.ble = ble
@@ -139,6 +109,37 @@ def __init__(self, ble, display, circ, heart=True, speed=True, cad=True, ams=Tru
         self.hr_connection = None
 
         self.num_enabled = heart + speed + cad + ams
+
+        self._previous_wheel = 0
+        self._previous_crank = 0
+        self._previous_revolutions = 0
+        self._previous_rev = 0
+        self._previous_speed = 0
+        self._previous_cadence = 0
+        self._previous_heart = 0
+        self._speed_failed = 0
+        self._cad_failed = 0
+        self._setup = 0
+        self._hr_label = None
+        self._sp_label = None
+        self._cad_label = None
+        self._ams_label = None
+        self._hr_service = None
+        self._heart_y = None
+        self._speed_y = None
+        self._cad_y = None
+        self._ams_y = None
+
+        self.ams = None
+        self.cyc_connections = None
+        self.cyc_services = None
+
+        self.start = time.time()
+        self.track_artist = True
+
+        self.splash = displayio.Group(max_size=25)
+        self.loading_group = displayio.Group()
+
         self._load_fonts()
 
         self.sprite_sheet, self.palette = adafruit_imageload.load("/sprite_sheet.bmp",
@@ -191,28 +192,29 @@ def _status_update(self, message):
             print(message)
             return
 
-        text_group = displayio.Group()
-        if len(message) > 25:
+        if len(self.loading_group) == 3:
+            text_group = displayio.Group()
             status = label.Label(font=self.arial12, x=10, y=200,
-                                 text=message[:25], color=self.YELLOW)
+                                 text='', color=self.YELLOW, max_glyphs=30)
             status1 = label.Label(font=self.arial12, x=10, y=220,
-                                  text=message[25:], color=self.YELLOW)
+                                  text='', color=self.YELLOW, max_glyphs=30)
 
             text_group.append(status)
             text_group.append(status1)
-        else:
-            status = label.Label(font=self.arial12, x=10, y=200, text=message, color=self.YELLOW)
-            text_group.append(status)
-
+            self.loading_group.append(text_group)
 
+        if len(message) > 25:
+            status.text = message[:25]
+            status1.text = message[25:]
 
-        if len(self.loading_group) < 4:
-            self.loading_group.append(text_group)
+            text_group.append(status)
+            text_group.append(status1)
         else:
-            self.loading_group[3] = text_group
+            status.text = message
+            status1.text = ''
+            text_group.append(status)
 
-        self.display.show(self.loading_group)
-        time.sleep(0.01)
+        #self.display.show(self.loading_group)
 
 
     def timeout(self):
@@ -239,7 +241,13 @@ def heart_connect(self):
             self._hr_service = self.hr_connection[HeartRateService]
         return self.hr_connection
 
-    def ams_connect(self):
+    @staticmethod
+    def _has_timed_out(start, timeout):
+        if time.time() - start >= timeout:
+            return True
+        return False
+
+    def ams_connect(self, start=time.time(), timeout=30):
         """
         Connect to an Apple device using the ble_apple_media library
         """
@@ -249,7 +257,7 @@ def ams_connect(self):
         a.solicited_services.append(AppleMediaService)
         radio.start_advertising(a)
 
-        while not radio.connected:
+        while not radio.connected and not self._has_timed_out(start, timeout):
             pass
 
         self._status_update("AppleMediaService: Connected")
@@ -300,7 +308,7 @@ def speed_cad_connect(self):
         return self.cyc_connections
 
 
-    def _speed_helper(self, values):
+    def _compute_speed(self, values):
         wheel_diff = values.last_wheel_event_time - self._previous_wheel
         rev_diff = values.cumulative_wheel_revolutions - self._previous_revolutions
 
@@ -314,15 +322,15 @@ def _speed_helper(self, values):
                 speed = self._previous_speed
             self._previous_speed = speed
             self._previous_revolutions = values.cumulative_wheel_revolutions
-            self._i = 0
+            self._speed_failed = 0
         else:
-            self._i += 1
-            if self._i >= 3:
+            self._speed_failed += 1
+            if self._speed_failed >= 3:
                 speed = 0
         self._previous_wheel = values.last_wheel_event_time
 
 
-    def _cad_helper(self, values):
+    def _compute_cadence(self, values):
         crank_diff = values.last_crank_event_time - self._previous_crank
         crank_rev_diff = values.cumulative_crank_revolutions-self._previous_rev
 
@@ -334,10 +342,10 @@ def _cad_helper(self, values):
                 cadence = self._previous_cadence
             self._previous_cadence = cadence
             self._previous_rev = values.cumulative_crank_revolutions
-            self._j = 0
+            self._cad_failed = 0
         else:
-            self._j += 1
-            if self._j >= 3:
+            self._cad_failed += 1
+            if self._cad_failed >= 3:
                 cadence = 0
         self._previous_crank = values.last_crank_event_time
 
@@ -356,23 +364,23 @@ def read_s_and_c(self):
             values = svc.measurement_values
 
             if not values:
-                if self._j >= 3 or self._i >= 3:
-                    if self._j > 3:
+                if self._cad_failed >= 3 or self._speed_failed >= 3:
+                    if self._cad_failed > 3:
                         cadence = 0
-                    if self._i > 3:
+                    if self._speed_failed > 3:
                         speed = 0
                 continue
 
             if not values.last_wheel_event_time:
                 continue
 
-            self._speed_helper(values)
+            self._compute_speed(values)
 
 
             if not values.last_crank_event_time:
                 continue
 
-            self._cad_helper(values)
+            self._compute_cadence(values)
 
         return speed, cadence