Esempio n. 1
0
    def update(self):
        if self._device['last_update'] is None or (
                datetime.now() - self._device['last_update']
        ).total_seconds() > self.__UPDATE_TIMEOUT:
            start = time.time()
            logger.debug(
                f'Loading online weather data from source: {self.address}')

            if self._load_data():
                # Convert values to the right unit values
                for day in self._data['days']:
                    day['temp'] = terrariumUtils.conver_to_value(
                        day['temp'],
                        self._device['unit_values']['temperature'])
                    day['wind']['speed'] = terrariumUtils.conver_to_value(
                        day['wind']['speed'],
                        self._device['unit_values']['windspeed'])

                # TODO: Change to list!!!!
                for forecast in self._data['forecast']:
                    forecast['temperature'] = terrariumUtils.conver_to_value(
                        forecast['temperature'],
                        self._device['unit_values']['temperature'])

                for history in self._data['history']:
                    history['temperature'] = terrariumUtils.conver_to_value(
                        history['temperature'],
                        self._device['unit_values']['temperature'])

                self._device['last_update'] = datetime.now()
                logger.info(
                    terrariumUtils.clean_log_line(
                        f'Loaded new weather data in {time.time()-start:.3f} seconds.'
                    ))
            else:
                logger.error(
                    terrariumUtils.clean_log_line(
                        f'Error loading online weather data! Please check your source address: {self.address}.'
                    ))
Esempio n. 2
0
    def get_current(self, force=False):
        if self.__current_value is None:
            return None

        return terrariumUtils.conver_to_value(self.__current_value,
                                              self.get_indicator())
Esempio n. 3
0
    def update(self, force=False):
        starttime = time()
        cached_data = self.__sensor_cache.get_sensor_data(
            self.get_sensor_cache_key())

        if (cached_data is None
                or force) and not self.__sensor_cache.is_running(
                    self.get_sensor_cache_key()):
            self.__sensor_cache.set_running(self.get_sensor_cache_key())
            logger.debug(
                'Start getting new {} sensor data from location: \'{}\''.
                format(self.get_sensor_type(), self.get_address()))
            new_data = self.load_data()

            if new_data is not None:
                self.__sensor_cache.set_sensor_data(
                    self.get_sensor_cache_key(), new_data,
                    terrariumSensor.UPDATE_TIMEOUT)
                cached_data = new_data

            self.__sensor_cache.clear_running(self.get_sensor_cache_key())

        current = None if cached_data is None or self.get_sensor_type(
        ) not in cached_data else cached_data[self.get_sensor_type()]
        if current is None or not (
                self.get_limit_min() <= terrariumUtils.conver_to_value(
                    current, self.get_indicator()) <= self.get_limit_max()):
            # Invalid current value.... log and ingore
            self.__sensor_cache.clear_sensor_data(self.get_sensor_cache_key())
            logger.warning(
                'Measured value %s%s from %s sensor \'%s\' is outside valid range %.2f%s - %.2f%s in %.5f seconds.'
                % (terrariumUtils.conver_to_value(
                    current, self.get_indicator()), self.get_indicator(),
                   self.get_type(), self.get_name(), self.get_limit_min(),
                   self.get_indicator(), self.get_limit_max(),
                   self.get_indicator(), time() - starttime))

        elif not self.__within_limits(
                terrariumUtils.conver_to_value(current, self.get_indicator())):
            self.__erratic_errors += 1
            logger.warning(
                'Measured value %s%s from %s sensor \'%s\' is erratic compared to previous value %s%s in %.5f seconds.'
                % (terrariumUtils.conver_to_value(
                    current, self.get_indicator()), self.get_indicator(),
                   self.get_type(), self.get_name(), self.__current_value,
                   self.get_indicator(), time() - starttime))
            if self.__erratic_errors >= 5:
                # After 5 times, use the current value as the new truth
                self.__erratic_errors = 0
                self.__current_value = current
                self.__last_update = int(starttime)
                logger.warning(
                    'After %s erratic measurements is the current value %s%s is promoted to a valid value for %s sensor \'%s\' in %.5f seconds.'
                    % (self.__erratic_errors, self.get_current(),
                       self.get_indicator(), self.get_type(), self.get_name(),
                       time() - starttime))

            else:
                self.__sensor_cache.clear_sensor_data(
                    self.get_sensor_cache_key())

        else:
            self.__erratic_errors = 0

            self.__last_update = int(starttime)
            logger.info(
                'Updated %s sensor \'%s\' from %.2f%s to %.2f%s in %.5f seconds'
                %
                (self.get_type(), self.get_name(),
                 0 if self.get_current() is None else self.get_current(),
                 self.get_indicator(),
                 terrariumUtils.conver_to_value(current, self.get_indicator()),
                 self.get_indicator(), time() - starttime))
            self.__current_value = current