Merge pull request #34 from jef41/bugfix

RC 0.1.2 testing

Author: jef41

bridge/lib/bridge_main.py

@@ -1,8 +1,4 @@
-''' works in principle with async 
-    could look at running wifi from core1 - doesn't seem to work
-    look at running ble collection on core1
-    nearly at __version__ 1.0.0
-        requires some code tidying - remove comments & old commented out code that is not used
+''' central handler holds most coros & passes data between
 '''
 import logging
 import gc
@@ -56,13 +52,13 @@ def __init__(self):
     def initialised(self):
         return self.rtc
 
-    async def bridge_main(self, onboard_led, providers, simulate_beacons: bool = False):
+    async def bridge_main(self, onboard_led, simulate_beacons: bool = False):
         gc.collect()
         self.onboard_led = onboard_led
-        if providers is None:
-            self.providers = self.get_providers()
-        else:
-            self.providers = providers
+        #if providers is None:
+        #    self.providers = self.set_providers()
+        #else:
+        #    self.providers = providers
         # add any webhooks defined in config
         # todo !! not currently implemented/tested
         self.webhook_providers = self._get_webhook_providers()
@@ -80,7 +76,7 @@ async def bridge_main(self, onboard_led, providers, simulate_beacons: bool = Fal
                 provider__start_message = provider.start() #todo look into this
                 if not provider__start_message:
                     provider__start_message = ''
-                self.logger.info("...started: {} {}".format(provider, provider__start_message))
+                self.logger.info(f"...started: {provider} {provider__start_message}")
                 # find configured colours
                 for colour in provider.col_dest.keys():
                     if colour not in self.enabled_colours:
@@ -125,7 +121,7 @@ async def bridge_main(self, onboard_led, providers, simulate_beacons: bool = Fal
             print('Trapped cancelled error.')
             raise
         except KeyboardInterrupt:
-            # todo: is this actioned here? investigate
+            # this is not usually actioned here, calling async coro captures the KB interrupt
             print("cancelling tasks...")
             self.handler.cancel()
             self.scanner.cancel()
@@ -165,9 +161,9 @@ async def _scan_for_ibeacons(self, simulate=False):
                     await task # then wait for task to complete
                     #res = await asyncio.gather(t1,t2, return_exceptions=True)
                 except asyncio.TimeoutError:  # These only happen if return_exceptions is False
-                    print('Timeout')  # With the default times, cancellation occurs first
+                    logger.warning('scanner Timeout')  # With the default times, cancellation occurs first
                 except asyncio.CancelledError:
-                    print('Cancelled')
+                    logger.warning('scanner Cancelled')
                 #asyncio.sleep_ms(randrange(100, 750))
                 #pckt_complete = True
             else:
@@ -179,9 +175,10 @@ async def _scan_for_ibeacons(self, simulate=False):
                         async for result in scanner:
                             if result.adv_data and result.adv_data[5:11] == iBeacon_prefix:
                                 #print("match")
-                                rssi = result.rssi
+                                #rssi = result.rssi
                                 # Extract and process iBeacon data
                                 #await _beacon_callback(iBeacon_data, rssi, simulate)
+                                #print(f"RSSI:{result.rssi}")
                                 iBeacon_data = iBeaconStatus(result.adv_data, result.rssi, result.device.addr_hex())
                                 #print(iBeacon_data)
                                 await self._beacon_callback(iBeacon_data, simulate)
@@ -322,8 +319,7 @@ def _get_webhook_providers(self):
             webhook_providers.append(WebhookCloudProvider(url, self.config))
         return webhook_providers
 
-    def get_providers(self, network=False):
-        #
+    def set_providers(self, network=False):
         if network:
             normal_providers = [
                     #PrometheusCloudProvider(self.config),
@@ -342,7 +338,7 @@ def get_providers(self, network=False):
                     CSVFileProvider(self.config),
                 ]
             self.logger.warning('No network credentials specified. Enabling local CSV logging only.')
-        return normal_providers
+        self.providers = normal_providers
 
     def get_time(self):
         result = False
@@ -361,24 +357,28 @@ def max_av_period(providers, colours):
     # this is how many records from each tilt that will be saved
     # called once per colour?
     col_max = {}
-    max_av = 0
+    max_av = 30
     try:
         for provider in providers:
             #print(f"***  colours {colours}")
             for colour in colours:
-                #print(f"***  test {provider}: {colour}, {provider.col_dest.keys()}")
-                if colour in provider.col_dest.keys() and provider.averaging_period >= max_av -1:
-                    #print(f"***   colour match: {colour}")
-                    max_av = provider.averaging_period + 1 # so if passed 0 then this will still work
-                    col_max[colour] = max_av
+                # print(f"***  test {provider}: {colour}, {provider.col_dest.keys()}")
+                if colour in provider.col_dest.keys() and provider.averaging_period > max_av:
+                    # print(f"***   colour match: {colour}")
+                    #max_av = provider.averaging_period + 1 # so if passed 0 then this will still work
+                    # keep a minimum of 30 secs worth or readings
+                    #max_av = provider.averaging_period + 1 if max_av < 30 else max_av
+                    #col_max[colour] = max_av
+                    max_av = provider.averaging_period
                     #print(f"***   {col_max}")
                 else:
                     #print(f"***   no match {colour} av_period {provider.averaging_period}")
                     pass
+            col_max.update({colour: max_av})
     except Exception as e:
         self.logger.error(f"max_av_period error: {e}")
         raise
-    #logger.debug(f"col_max: {col_max}")
+    #print(f"col_max: {col_max}")
     return col_max
 
 async def debug_memory(logger):

bridge/lib/configuration/bridge_config.py

@@ -14,10 +14,9 @@ def __init__(self, data: dict):
         self.wifi_check_interval = 3600
         # Debug log
         self.debug_log = [20, 1]
-        # Queue
-        self.queue_size = 15
-        self.queue_empty_sleep_seconds = 1
-        self.averaging_period = 30 # 0 21000
+        # Defaults
+        self.default_averaging_period = 30
+        self.default_temp_unit = "C"
         # Broadcast Data ranges
         self.temp_range_min = 32
         self.temp_range_max = 212
@@ -28,8 +27,6 @@ def __init__(self, data: dict):
         self.webhook_limit_rate = 1
         self.webhook_limit_period = 1
         # CSV File
-        #self.csv_log_max_kb = 60
-        self.csv_log_temp_unit = "C"
         self.csv_log_period = 60
         self.csv_bkp_count = 4
         #self.csv_log_averaging_period = 60
@@ -80,22 +77,71 @@ def update(self, data: dict):
 
     def get_original_gravity(self, colour: str):
         return self.__dict__.get(colour + '_original_gravity')
+        #return getattr(self,colour + '_original_gravity', None)
 
-    def get_temp_offset(self, colour: str):
-        return self.__dict__.get(colour + '_temp_offset', 0)
+    #def get_temp_offset(self, colour: str):
+    #    return self.__dict__.get(colour + '_temp_offset', 0)
 
     def get_brew_name(self, colour: str):
         return self.__dict__.get(colour + '_name', colour)
+        #return getattr(self, colour + '_name', colour)
 
     def get_gravity_offsets(self, colour: str):
         ''' return a list of offsets
             where in each pair 1st value = raw, 2nd value = reference point;
                 [[1.002,1.000],[1.107,1.100]]
         '''
         cal_vals = self.__dict__.get(colour + '_gravity_offsets')
+        #cal_vals = getattr(self, colour + '_gravity_offsets')
         return cal_vals
 
+    def get_temp_offsets(self, colour: str):
+        ''' return a list of offsets
+            index 0 is 'F' or 'C'
+            each following pair 1st value = raw, 2nd value = reference point;
+                ['C', [5.5,5.0],[25.1,25.0]]
+        '''
+        #cal_vals = list(self.__dict__.get(colour + '_temp_offsets'))
+        cal_vals = list(getattr(self, colour + '_temp_offsets', []))
+        # make a new variable, not pointer to same one
+        try:
+            if cal_vals[0].upper() == 'C':
+                #convert to F
+                cal_vals.pop(0)
+                cal_vals =[[(temp * 9/5) + 32 for temp in pair] for pair in cal_vals]
+            else:
+                cal_vals.pop(0)
+        except Exception as e:
+            cal_vals = None
+            # print(e)
+            raise type(e)(f"Error in bridge config: {e}") from e
+        finally:
+            #print(f"cal vals:{cal_vals}")
+            return cal_vals
+
+    def get_temp_unit(self, lookup_key, name=False):
+        ''' Look up a provider temp_unit key in config, fall back to default config.temp_unit,
+           and return either a single char or the full name (e.g., C or celsius).
+        '''
+        #temp_unit = self.__dict__.get(lookup_key, getattr(self, "default_temp_unit", "C"))
+        temp_unit = getattr(self, lookup_key, self.default_temp_unit)
+
+        if temp_unit not in ("C", "c", "F", "f"):
+            raise ValueError(f"{lookup_key} temp unit must be specified as 'C' or 'F'")
 
+        if temp_unit in ("C", "c"):
+            return "celsius" if name else "C"
+        
+        return "fahrenheit" if name else "F"
+
+    def get_averaging_period(self, lookup_key):
+        ''' look up the provider averaging period,
+            if not present fall back to the default averaging period
+            return an integer of seconds
+        '''
+        #return self.__dict__.get(lookup_key, getattr(self, lookup_key, self.default_averaging_period))
+        return getattr(self, lookup_key, self.default_averaging_period)
+    
     @staticmethod
     def load(additional_config: dict = None):
         file_path = "/config.json"

bridge/lib/indicator.py

@@ -1,30 +1,38 @@
+''' manage the Pico onboard LED
+    TODO could verify that we are on a Pico & if not try to import the pin number from pin_mapping
+'''
 from machine import Pin
 import time
 import asyncio
 
+
 class Status():
-    ''' 
-        an indicator LED
-    '''
     STATUS_OK = (10,3000)
     WIFI_CONNECTING = (10,400)
     WIFI_CONNECTED = (200,800)
     WIFI_DISCONNECTED = (800,200)
     STARTUP = (500,0)
-    def __init__(self):
+    STATUS_ERROR = (500,0)
+    ''' 
+        an indicator LED
+    '''
+    def __init__(self, status=STARTUP):
         self.led = Pin('LED', Pin.OUT)
-        self.on_period = self.STARTUP[0] #ms
-        self.off_period = self.STARTUP[1] #ms
+        self.on_period = status[0] #ms
+        self.off_period = status[1] #ms
         self.blinky = asyncio.create_task(self._blink_led())
         #asyncio.run(self._start())
 
     async def _blink_led(self):
         #led = Pin('LED', Pin.OUT)
+        #print("called led blink")
         while True:
             if self.off_period == 0:
+                #print("led solid on")
                 self.led.on() # otherwsie acts as a sort of 'busy' indicator
-                await asyncio.sleep_ms(100)
+                await asyncio.sleep_ms(self.on_period+10)
             else:
+                #print("led blink")
                 self.led.on()
                 await asyncio.sleep_ms(self.on_period)
                 self.led.off()
@@ -46,8 +54,11 @@ async def off(self):
         self.blinky.cancel()
         self.led.off()
 
-    async def _start(self):
-        self.blinky = asyncio.create_task(self._blink_led())
+    #async def _start(self):
+    #    self.blinky = asyncio.create_task(self._blink_led())
+        
+    def on(self):
+        self.led.on()
 
 
 async def test():

bridge/lib/models/provider_timer.py

@@ -16,6 +16,7 @@ def __init__(self):
 
     def add(self, provider, period, adjust=None):
         #adjust = None if adjust == 0 else adjust # ensure we don't set invalid adjustment period
+        # the initial call sends the averagin_period to adjust
         adjust = 10 if adjust == 0 else adjust # ensure we don't set invalid adjustment period, set to small value to force initial upload
         self.timer_list[provider] = self._get_new_timer(period, adjust)
 
@@ -55,14 +56,15 @@ def __init__(self, default_period, adjust=None):
         # in which case call with default_period=900, adjust=300
         self.upload_due = asyncio.Event()
         #self.upload_due.clear()
-        self.default_period = default_period*1000 if default_period else 1000 # default to 1 second if averaging set to 0
+        #self.default_period = default_period*1000 if default_period else 10000 # default to 10s secs if averaging set to 0
+        self.default_period = default_period*1000 # change to ms
         self.adjusted = False
         if adjust is not None:
             adjust = adjust*1000
             self.adjusted = True
         self.reinit(self.default_period if adjust is None else adjust)
         #self.upload_timer = Timer(period=self.default_period, mode=Timer.PERIODIC, callback=self.provider_callback)
-        logger.debug(f"timer created with period {self.default_period if adjust is None else adjust}")
+        logger.debug(f"timer created with {"adjusted" if adjust else "default"} period {self.default_period//1000 if adjust is None else adjust//1000}secs")
 
     def provider_callback(self, timer):
         # set the thread safe flag

bridge/lib/models/tilt_history.py

@@ -210,10 +210,19 @@ def get_most_recent(self, limit):
             startb = self._wi - self.record_len
             stopb =-1 * self.record_len
             stepb = -1 * self.record_len
+            latest_i = 0 if startb < 0 else startb
             #print(f"start, stop, step {startb}, {stopb}, {stepb}")
-            for latest_i in range(startb, stopb, stepb):
-                #latest_i = self._wi - self.record_len
-                #print(f"***  testing {latest_i}")
+            steps = self._size / self.record_len
+            #print(f"steps:{steps}, mv:{self._size}")
+            #for latest_i in range(startb, stopb, stepb):
+            for i in range(steps):
+                #print(f"get byte {latest_i}")
+                #    latest_i = (steps + 1) * startb
+                #    #latest_i = self._wi - self.record_len
+                #    #print(f"***  testing {latest_i}")
+                # Loop through it 7 bytes at a time, starting from index 0 and then moving backwards
+                # Loop: Start from index 0, then move backwards in steps of 7
+                #for i in [0] + list(range(len(byte_array) - 7, 0, -7)):
                 q_timestmp = mv_data[0+latest_i] | mv_data[1+latest_i]<<8 | mv_data[2+latest_i]<<16 | mv_data[3+latest_i]<<24
                 logger.debug(f"timestamp:{q_timestmp} limit:{limit}")
                 if q_timestmp > int(limit): # we have a match 
@@ -223,6 +232,8 @@ def get_most_recent(self, limit):
                     #logger.debug(f"{mv_data[4+i]} {mv_data[5+i]} {mv_data[6+i]}")
                     num_results += 1
                     break
+                # Move backwards with wrap-around
+            latest_i = (latest_i - self.record_len) % self._size
         except Exception as e:
             logger.debug(f"Error in get_most_recent: {e}")
             raise e