def save_weather_data(self, raw_data, last_reading=None):
        """
        Convert NVP format to django record
        """
        if last_reading is None:
            last_reading = timezone.now()
        EMPTY = Decimal('0.00')

        # Create a weather reading.from the retrieved data.
        if self.manufacturer == 'vaisala':
            # Vaisala data is a comma-separated NVP format.
            items = raw_data.split(',')
            items.pop(0)  # Remove the first element of the raw data.
            data = {}
            for item in items:
                k, v = item.split('=')
                data[k] = v
            reading = WeatherObservation()
            reading.temperature = Decimal(data.get('Ta')[:-1])
            reading.humidity = Decimal(data.get('Ua')[:-1])
            reading.dew_point = dew_point(float(reading.temperature),
                                          float(reading.humidity))
            reading.pressure = Decimal(data.get('Pa')[:-1])
            reading.wind_direction_min = Decimal(data.get('Dn')[:-1])
            reading.wind_direction_max = Decimal(data.get('Dx')[:-1])
            reading.wind_direction = Decimal(data.get('Dm')[:-1])
            reading.wind_speed_min = Decimal(data.get('Sn')[:-1]) * KNOTS_TO_MS
            reading.wind_speed_min_kn = Decimal(data.get('Sn')[:-1])
            reading.wind_speed_max = Decimal(data.get('Sx')[:-1]) * KNOTS_TO_MS
            reading.wind_speed_max_kn = Decimal(data.get('Sx')[:-1])
            reading.wind_speed = Decimal(data.get('Sm')[:-1]) * KNOTS_TO_MS
            reading.wind_speed_kn = Decimal(data.get('Sm')[:-1])
            reading.rainfall = Decimal(data.get('Rc')[:-1])
            reading.actual_rainfall = actual_rainfall(Decimal(reading.rainfall),
                                                      self, last_reading)
            reading.actual_pressure = actual_pressure(float(reading.temperature),
                                                      float(reading.pressure),
                                                      float(self.location.height))
            reading.raw_data = raw_data
            reading.station = self
            reading.save()
            self.last_reading = last_reading
            self.battery_voltage = Decimal(data.get('Vs')[:-1])
            self.save()
        else:  # Default to using the Telvent station format.
            # Telvent data is stored in NVP format separated by the pipe symbol '|'.
            #   |<NAME>=<VALUE>|
            items = raw_data.split('|')
            data = {}
            for item in items:
                if (item != ''):
                    try:
                        k, v = item.split('=')
                        data[k] = v
                    except:
                        pass

            reading = WeatherObservation()
            reading.temperature_min = data.get('TN') or EMPTY
            reading.temperature_max = data.get('TX') or EMPTY
            reading.temperature = data.get('T') or EMPTY
            reading.temperature_deviation = data.get('TS') or EMPTY
            reading.temperature_outliers = data.get('TO') or 0
            reading.pressure_min = data.get('QFEN') or EMPTY
            reading.pressure_max = data.get('QFEX') or EMPTY
            reading.pressure = data.get('QFE') or EMPTY
            reading.pressure_deviation = data.get('QFES') or EMPTY
            reading.pressure_outliers = data.get('QFEO') or 0
            reading.humidity_min = data.get('HN') or EMPTY
            reading.humidity_max = data.get('HX') or EMPTY
            reading.humidity = data.get('H') or EMPTY
            reading.humidity_deviation = data.get('HS') or EMPTY
            reading.humidity_outliers = data.get('HO') or 0
            reading.wind_direction_min = data.get('DN') or EMPTY
            reading.wind_direction_max = data.get('DX') or EMPTY
            reading.wind_direction = data.get('D') or EMPTY
            reading.wind_direction_deviation = data.get('DS') or EMPTY
            reading.wind_direction_outliers = data.get('DO') or 0
            if (data.get('SN')):
                reading.wind_speed_min = Decimal(data.get('SN')) * KNOTS_TO_MS or 0
                reading.wind_speed_min_kn = Decimal(data.get('SN')) or 0
                reading.wind_speed_deviation = Decimal(data.get('SS')) * KNOTS_TO_MS or 0
                reading.wind_speed_outliers = data.get('SO') or 0
                reading.wind_speed_deviation_kn = Decimal(data.get('SS')) or 0
            if (data.get('SX')):
                reading.wind_speed_max = Decimal(data.get('SX')) * KNOTS_TO_MS or 0
                reading.wind_speed_max_kn = Decimal(data.get('SX')) or 0
            if (data.get('S')):
                reading.wind_speed = Decimal(data.get('S')) * KNOTS_TO_MS or 0
                reading.wind_speed_kn = Decimal(data.get('S')) or 0
            reading.rainfall = data.get('R') or EMPTY
            reading.dew_point = dew_point(float(reading.temperature),
                                          float(reading.humidity))
            reading.actual_rainfall = actual_rainfall(Decimal(reading.rainfall),
                                                      self, last_reading)
            reading.actual_pressure = actual_pressure(float(reading.temperature),
                                                      float(reading.pressure),
                                                      float(self.location.height))
            reading.raw_data = raw_data
            reading.station = self
            reading.save()
            self.last_reading = last_reading
            self.battery_voltage = data.get('BV', EMPTY) or EMPTY
            self.save()

        return reading
Esempio n. 2
0
    def save_observation(self, raw_data):
        """Convert a raw observation and save it to the database.
        """
        observation = WeatherObservation(station=self, raw_data=raw_data)
        data = {}

        # Parse the observation string into a dict.
        if self.manufacturer == 'vaisala':
            items = raw_data.split(',')
        elif self.manufacturer == 'telvent':
            items = raw_data.split('|')
        items.pop(0)  # Always remove the first element of the raw data (not a key-value pair).
        for item in items:
            k, v = item.split('=')
            data[k] = v

        # Parse the datestamp (if absent, observation will default to timezone.now())
        if 'Date' in data and 'Time' in data:
            ts = '{} {}'.format(data['Date'], data['Time'])
            observation.date = timezone.make_aware(datetime.strptime(ts, '%Y-%m-%d %H:%M:%S'))

        if self.manufacturer == 'vaisala':
            pattern = '(\d+(\.\d+)?)(.+)'
            if 'Ta' in data:
                observation.temperature = Decimal(re.search(pattern, data['Ta']).group(1))
            if 'Ua' in data:
                observation.humidity = Decimal(re.search(pattern, data['Ua']).group(1))
            if observation.temperature and observation.humidity:
                observation.dew_point = dew_point(
                    float(observation.temperature), float(observation.humidity))
            if 'Pa' in data:
                observation.pressure = Decimal(re.search(pattern, data['Pa']).group(1))
            if observation.temperature and observation.pressure:
                observation.actual_pressure = actual_pressure(
                    float(observation.temperature), float(observation.pressure), float(self.location.height))
            if 'Dn' in data:
                observation.wind_direction_min = Decimal(re.search(pattern, data['Dn']).group(1))
            if 'Dx' in data:
                observation.wind_direction_max = Decimal(re.search(pattern, data['Dx']).group(1))
            if 'Dm' in data:
                observation.wind_direction = Decimal(re.search(pattern, data['Dm']).group(1))
            if 'Sn' in data:
                observation.wind_speed_min = Decimal(re.search(pattern, data['Sn']).group(1)) * KNOTS_TO_MS
                observation.wind_speed_min_kn = Decimal(re.search(pattern, data['Sn']).group(1))
            if 'Sx' in data:
                observation.wind_speed_max = Decimal(re.search(pattern, data['Sx']).group(1)) * KNOTS_TO_MS
                observation.wind_speed_max_kn = Decimal(re.search(pattern, data['Sx']).group(1))
            if 'Sm' in data:
                observation.wind_speed = Decimal(re.search(pattern, data['Sm']).group(1)) * KNOTS_TO_MS
                observation.wind_speed_kn = Decimal(re.search(pattern, data['Sm']).group(1))
            if 'Rc' in data:
                observation.rainfall = Decimal(re.search(pattern, data['Rc']).group(1))
            if observation.date and observation.rainfall:
                observation.actual_rainfall = actual_rainfall(Decimal(observation.rainfall), self, observation.date)
            else:
                observation.actual_rainfall = 0.0
            if 'Vs' in data:
                self.battery_voltage = Decimal(re.search(pattern, data['Vs']).group(1))
        elif self.manufacturer == 'telvent':
            if 'T' in data:
                observation.temperature = data['T']
            if 'TN' in data:
                observation.temperature_min = data['TN']
            if 'TX' in data:
                observation.temperature_max = data['TX']
            if 'TS' in data:
                observation.temperature_deviation = data['TS']
            if 'TO' in data:
                observation.temperature_outliers = data['TO']
            if 'QFE' in data:
                observation.pressure = data['QFE']
            if 'QFEN' in data:
                observation.pressure_min = data['QFEN']
            if 'QFEX' in data:
                observation.pressure_max = data['QFEX']
            if 'QFES' in data:
                observation.pressure_deviation = data['QFES']
            if 'QFEO' in data:
                observation.pressure_outliers = data['QFEO']
            if 'H' in data:
                observation.humidity = data['H']
            if 'HN' in data:
                observation.humidity_min = data['HN']
            if 'HX' in data:
                observation.humidity_max = data['HX']
            if 'HS' in data:
                observation.humidity_deviation = data['HS']
            if 'HO' in data:
                observation.humidity_outliers = data['HO']
            if 'D' in data:
                observation.wind_direction = data['D']
            if 'DN' in data:
                observation.wind_direction_min = data['DN']
            if 'DX' in data:
                observation.wind_direction_max = data['DX']
            if 'DS' in data:
                observation.wind_direction_deviation = data['DS']
            if 'DO' in data:
                observation.wind_direction_outliers = data['DO']
            if 'S' in data:
                observation.wind_speed = Decimal(data['S']) * KNOTS_TO_MS
                observation.wind_speed_kn = Decimal(data['S'])
            if 'SN' in data:
                observation.wind_speed_min = Decimal(data['SN']) * KNOTS_TO_MS
                observation.wind_speed_min_kn = Decimal(data['SN'])
            if 'SS' in data:
                observation.wind_speed_deviation = Decimal(data['SS']) * KNOTS_TO_MS
                observation.wind_speed_deviation_kn = Decimal(data['SS'])
            if 'SO' in data:
                observation.wind_speed_outliers = data['SO']
            if 'SX' in data:
                observation.wind_speed_max = Decimal(data['SX']) * KNOTS_TO_MS
                observation.wind_speed_max_kn = Decimal(data['SX'])
            if 'R' in data:
                observation.rainfall = data['R']
                observation.actual_rainfall = actual_rainfall(Decimal(observation.rainfall), self, observation.date)
            else:
                observation.actual_rainfall = 0.0
            if observation.temperature and observation.humidity:
                observation.dew_point = dew_point(
                    float(observation.temperature), float(observation.humidity))
            if observation.temperature and observation.pressure:
                observation.actual_pressure = actual_pressure(
                    float(observation.temperature), float(observation.pressure), float(self.location.height))
            if 'BV' in data:
                self.battery_voltage = data['BV']

        observation.save()
        self.last_reading = observation.date
        self.save()
        return observation
Esempio n. 3
0
    def save_weather_data(self, raw_data, last_reading=None):
        """
        Convert NVP format to django record
        """
        if last_reading is None:
            last_reading = timezone.now()

        # Data is stored in NVP format separated by the pipe symbol '|'.
        #   |<NAME>=<VALUE>|
        items = raw_data.split('|')
        data = {}
        for item in items:
            if (item != ''):
                try:
                    key, value = item.split('=')
                    data[key] = value
                except:
                    pass

        EMPTY = Decimal('0.00')

        # Create a weather reading.from the retrieved data.
        reading = WeatherObservation()
        reading.temperature_min = data.get('TN') or EMPTY
        reading.temperature_max = data.get('TX') or EMPTY
        reading.temperature = data.get('T') or EMPTY
        reading.temperature_deviation = data.get('TS') or EMPTY
        reading.temperature_outliers = data.get('TO') or 0

        reading.pressure_min = data.get('QFEN') or EMPTY
        reading.pressure_max = data.get('QFEX') or EMPTY
        reading.pressure = data.get('QFE') or EMPTY
        reading.pressure_deviation = data.get('QFES') or EMPTY
        reading.pressure_outliers = data.get('QFEO') or 0

        reading.humidity_min = data.get('HN') or EMPTY
        reading.humidity_max = data.get('HX') or EMPTY
        reading.humidity = data.get('H') or EMPTY
        reading.humidity_deviation = data.get('HS') or EMPTY
        reading.humidity_outliers = data.get('HO') or 0

        reading.wind_direction_min = data.get('DN') or EMPTY
        reading.wind_direction_max = data.get('DX') or EMPTY
        reading.wind_direction = data.get('D') or EMPTY
        reading.wind_direction_deviation = data.get('DS') or EMPTY
        reading.wind_direction_outliers = data.get('DO') or 0
#10.3.11.100
#10.159.8.67

        if (data.get('SN')):
            reading.wind_speed_min = Decimal(data.get('SN')) * KNOTS_TO_MS or 0
            reading.wind_speed_min_kn = Decimal(data.get('SN')) or 0
            reading.wind_speed_deviation = Decimal(data.get('SS')) * KNOTS_TO_MS or 0
            reading.wind_speed_outliers = data.get('SO') or 0
            reading.wind_speed_deviation_kn = Decimal(data.get('SS')) or 0
        if (data.get('SX')):
            reading.wind_speed_max = Decimal(data.get('SX')) * KNOTS_TO_MS or 0
            reading.wind_speed_max_kn = Decimal(data.get('SX')) or 0

        if (data.get('S')):
            reading.wind_speed = Decimal(data.get('S'))      * KNOTS_TO_MS or 0
            reading.wind_speed_kn = Decimal(data.get('S'))      or 0

        reading.rainfall = data.get('R') or EMPTY

        try:
            reading.dew_point = dew_point(float(reading.temperature),
                                          float(reading.humidity))
            reading.actual_rainfall = actual_rainfall(Decimal(reading.rainfall),
                                                      self, last_reading)
            reading.actual_pressure = actual_pressure(float(reading.temperature),
                                                      float(reading.pressure),
                                                      float(self.location.height))
        except Exception, e:
            logger.error("We didnt get enough data to do these calculations because %s"%e)
Esempio n. 4
0
    def save_observation(self, raw_data):
        """Convert a raw observation and save it to the database.
        """
        observation = WeatherObservation(station=self, raw_data=raw_data)
        data = {}

        # Parse the observation string into a dict.
        if self.manufacturer == 'vaisala':
            items = raw_data.split(',')
        elif self.manufacturer == 'telvent':
            items = raw_data.split('|')
        items.pop(
            0
        )  # Always remove the first element of the raw data (not a key-value pair).
        for item in items:
            k, v = item.split('=')
            data[k] = v

        # Parse the datestamp (if absent, observation will default to timezone.now())
        if 'Date' in data and 'Time' in data:
            ts = '{} {}'.format(data['Date'], data['Time'])
            observation.date = timezone.make_aware(
                datetime.strptime(ts, '%Y-%m-%d %H:%M:%S'))

        if self.manufacturer == 'vaisala':
            pattern = '(\d+(\.\d+)?)(.+)'
            if 'Ta' in data:
                observation.temperature = Decimal(
                    re.search(pattern, data['Ta']).group(1))
            if 'Ua' in data:
                observation.humidity = Decimal(
                    re.search(pattern, data['Ua']).group(1))
            if observation.temperature and observation.humidity:
                observation.dew_point = dew_point(
                    float(observation.temperature),
                    float(observation.humidity))
            if 'Pa' in data:
                observation.pressure = Decimal(
                    re.search(pattern, data['Pa']).group(1))
            if observation.temperature and observation.pressure:
                observation.actual_pressure = actual_pressure(
                    float(observation.temperature),
                    float(observation.pressure), float(self.location.height))
            if 'Dn' in data:
                observation.wind_direction_min = Decimal(
                    re.search(pattern, data['Dn']).group(1))
            if 'Dx' in data:
                observation.wind_direction_max = Decimal(
                    re.search(pattern, data['Dx']).group(1))
            if 'Dm' in data:
                observation.wind_direction = Decimal(
                    re.search(pattern, data['Dm']).group(1))
            if 'Sn' in data:
                observation.wind_speed_min = Decimal(
                    re.search(pattern, data['Sn']).group(1)) * KNOTS_TO_MS
                observation.wind_speed_min_kn = Decimal(
                    re.search(pattern, data['Sn']).group(1))
            if 'Sx' in data:
                observation.wind_speed_max = Decimal(
                    re.search(pattern, data['Sx']).group(1)) * KNOTS_TO_MS
                observation.wind_speed_max_kn = Decimal(
                    re.search(pattern, data['Sx']).group(1))
            if 'Sm' in data:
                observation.wind_speed = Decimal(
                    re.search(pattern, data['Sm']).group(1)) * KNOTS_TO_MS
                observation.wind_speed_kn = Decimal(
                    re.search(pattern, data['Sm']).group(1))
            if 'Rc' in data:
                observation.rainfall = Decimal(
                    re.search(pattern, data['Rc']).group(1))
            if observation.date and observation.rainfall:
                observation.actual_rainfall = actual_rainfall(
                    Decimal(observation.rainfall), self, observation.date)
            else:
                observation.actual_rainfall = 0.0
            if 'Vs' in data:
                self.battery_voltage = Decimal(
                    re.search(pattern, data['Vs']).group(1))
        elif self.manufacturer == 'telvent':
            if 'T' in data:
                observation.temperature = data['T']
            if 'TN' in data:
                observation.temperature_min = data['TN']
            if 'TX' in data:
                observation.temperature_max = data['TX']
            if 'TS' in data:
                observation.temperature_deviation = data['TS']
            if 'TO' in data:
                observation.temperature_outliers = data['TO']
            if 'QFE' in data:
                observation.pressure = data['QFE']
            if 'QFEN' in data:
                observation.pressure_min = data['QFEN']
            if 'QFEX' in data:
                observation.pressure_max = data['QFEX']
            if 'QFES' in data:
                observation.pressure_deviation = data['QFES']
            if 'QFEO' in data:
                observation.pressure_outliers = data['QFEO']
            if 'H' in data:
                observation.humidity = data['H']
            if 'HN' in data:
                observation.humidity_min = data['HN']
            if 'HX' in data:
                observation.humidity_max = data['HX']
            if 'HS' in data:
                observation.humidity_deviation = data['HS']
            if 'HO' in data:
                observation.humidity_outliers = data['HO']
            if 'D' in data:
                observation.wind_direction = data['D']
            if 'DN' in data:
                observation.wind_direction_min = data['DN']
            if 'DX' in data:
                observation.wind_direction_max = data['DX']
            if 'DS' in data:
                observation.wind_direction_deviation = data['DS']
            if 'DO' in data:
                observation.wind_direction_outliers = data['DO']
            if 'S' in data:
                observation.wind_speed = Decimal(data['S']) * KNOTS_TO_MS
                observation.wind_speed_kn = Decimal(data['S'])
            if 'SN' in data:
                observation.wind_speed_min = Decimal(data['SN']) * KNOTS_TO_MS
                observation.wind_speed_min_kn = Decimal(data['SN'])
            if 'SS' in data:
                observation.wind_speed_deviation = Decimal(
                    data['SS']) * KNOTS_TO_MS
                observation.wind_speed_deviation_kn = Decimal(data['SS'])
            if 'SO' in data:
                observation.wind_speed_outliers = data['SO']
            if 'SX' in data:
                observation.wind_speed_max = Decimal(data['SX']) * KNOTS_TO_MS
                observation.wind_speed_max_kn = Decimal(data['SX'])
            if 'R' in data:
                observation.rainfall = data['R']
                observation.actual_rainfall = actual_rainfall(
                    Decimal(observation.rainfall), self, observation.date)
            else:
                observation.actual_rainfall = 0.0
            if observation.temperature and observation.humidity:
                observation.dew_point = dew_point(
                    float(observation.temperature),
                    float(observation.humidity))
            if observation.temperature and observation.pressure:
                observation.actual_pressure = actual_pressure(
                    float(observation.temperature),
                    float(observation.pressure), float(self.location.height))
            if 'BV' in data:
                self.battery_voltage = data['BV']

        observation.save()
        self.last_reading = observation.date
        self.save()
        return observation
Esempio n. 5
0
    def save_weather_data(self, raw_data, last_reading=None):
        """
        Convert NVP format to django record
        """
        if last_reading is None:
            last_reading = timezone.now()

        # Data is stored in NVP format separated by the pipe symbol '|'.
        #   |<NAME>=<VALUE>|
        items = raw_data.split("|")
        data = {}
        for item in items:
            if item != "":
                try:
                    key, value = item.split("=")
                    data[key] = value
                except:
                    pass

        EMPTY = Decimal("0.00")

        # Create a weather reading.from the retrieved data.
        reading = WeatherObservation()
        reading.temperature_min = data.get("TN") or EMPTY
        reading.temperature_max = data.get("TX") or EMPTY
        reading.temperature = data.get("T") or EMPTY
        reading.temperature_deviation = data.get("TS") or EMPTY
        reading.temperature_outliers = data.get("TO") or 0

        reading.pressure_min = data.get("QFEN") or EMPTY
        reading.pressure_max = data.get("QFEX") or EMPTY
        reading.pressure = data.get("QFE") or EMPTY
        reading.pressure_deviation = data.get("QFES") or EMPTY
        reading.pressure_outliers = data.get("QFEO") or 0

        reading.humidity_min = data.get("HN") or EMPTY
        reading.humidity_max = data.get("HX") or EMPTY
        reading.humidity = data.get("H") or EMPTY
        reading.humidity_deviation = data.get("HS") or EMPTY
        reading.humidity_outliers = data.get("HO") or 0

        reading.wind_direction_min = data.get("DN") or EMPTY
        reading.wind_direction_max = data.get("DX") or EMPTY
        reading.wind_direction = data.get("D") or EMPTY
        reading.wind_direction_deviation = data.get("DS") or EMPTY
        reading.wind_direction_outliers = data.get("DO") or 0
        # 10.3.11.100
        # 10.159.8.67

        if data.get("SN"):
            reading.wind_speed_min = Decimal(data.get("SN")) * KNOTS_TO_MS or 0
            reading.wind_speed_min_kn = Decimal(data.get("SN")) or 0
            reading.wind_speed_deviation = Decimal(data.get("SS")) * KNOTS_TO_MS or 0
            reading.wind_speed_outliers = data.get("SO") or 0
            reading.wind_speed_deviation_kn = Decimal(data.get("SS")) or 0
        if data.get("SX"):
            reading.wind_speed_max = Decimal(data.get("SX")) * KNOTS_TO_MS or 0
            reading.wind_speed_max_kn = Decimal(data.get("SX")) or 0

        if data.get("S"):
            reading.wind_speed = Decimal(data.get("S")) * KNOTS_TO_MS or 0
            reading.wind_speed_kn = Decimal(data.get("S")) or 0

        reading.rainfall = data.get("R") or EMPTY

        try:
            reading.dew_point = dew_point(float(reading.temperature), float(reading.humidity))
            reading.actual_rainfall = actual_rainfall(Decimal(reading.rainfall), self, last_reading)
            reading.actual_pressure = actual_pressure(
                float(reading.temperature), float(reading.pressure), float(self.location.height)
            )
        except Exception, e:
            logger.error("We didnt get enough data to do these calculations because %s" % e)