Esempio n. 1
0
def LogData(params, raw_data, sync=None, clear=False):
    logger = logging.getLogger('pywws.LogData')
    # connect to weather station
    ws_type = params.get('config', 'ws type', '1080')
    if ws_type:
        params._config.remove_option('config', 'ws type')
        params.set('fixed', 'ws type', ws_type)
    ws_type = params.get('fixed', 'ws type', '1080')
    ws = WeatherStation.weather_station(ws_type=ws_type)
    fixed_block = CheckFixedBlock(ws, params, logger)
    if not fixed_block:
        logger.error("Invalid data from weather station")
        return 3
    # get sync config value
    if sync is None:
        sync = int(params.get('config', 'logdata sync', '1'))
    # get address and date-time of last complete logged data
    logger.info('Synchronising to weather station')
    for data, last_ptr, logged in ws.live_data(logged_only=(sync > 0)):
        last_date = data['idx']
        logger.debug('Reading time %s', last_date.strftime('%H:%M:%S'))
        if logged:
            break
        if sync < 1 and last_date.second > 5 and last_date.second < 55:
            last_date = last_date.replace(second=0) - timedelta(minutes=data['delay'])
            last_ptr = ws.dec_ptr(last_ptr)
            break
    # go back through stored data, until we catch up with what we've already got
    logger.info('Fetching data')
    Catchup(ws, logger, raw_data, last_date, last_ptr)
    if clear:
        logger.info('Clearing weather station memory')
        ptr = ws.fixed_format['data_count'][0]
        ws.write_data([(ptr, 1), (ptr+1, 0)])
Esempio n. 2
0
 def GetData(self):
     while 1:
         try:
             for data, ptr, ret  in self.live_data():
                 
                 if ret :
                     
                     globalvars.meteo_data.status = data[ "status"]
                     
                     if globalvars.meteo_data.status == 0:
                         
                         globalvars.meteo_data.last_measure_time = datetime.datetime.now()
             
                         globalvars.meteo_data.wind_dir = data["wind_dir"]                    
                         globalvars.meteo_data.idx = data[ "idx"]
                         
                         globalvars.meteo_data.hum_out = data["hum_out"]
                         globalvars.meteo_data.wind_gust = (float(data["wind_gust"])*3.6)*self.cfg.windspeed_gain + self.cfg.windspeed_offset
                         globalvars.meteo_data.wind_ave = (float(data["wind_ave"])*3.6)*self.cfg.windspeed_gain + self.cfg.windspeed_offset
                         globalvars.meteo_data.rain = float(data["rain"])
                         globalvars.meteo_data.temp_in = float(data["temp_in"])
                         globalvars.meteo_data.delay = float(data["delay"])
                         globalvars.meteo_data.abs_pressure = float(data["abs_pressure"])
                         globalvars.meteo_data.hum_in = float(data["hum_in"])
                         globalvars.meteo_data.temp_out = float(data["temp_out"])
                         wind_dir = data[ "wind_dir"]
                         if ( wind_dir < 16 ):
                             globalvars.meteo_data.wind_dir = wind_dir * 22.5
                             globalvars.meteo_data.wind_dir_code = WeatherStation.get_wind_dir_text()[wind_dir]
                         else:
                             globalvars.meteo_data.wind_dir_code = None
                             globalvars.meteo_data.wind_dir_code = None
                             
                         globalvars.meteo_data.illuminance = None
                         globalvars.meteo_data.uv = None
                         
                         # TO REMOVE
                         if ( globalvars.meteo_data.abs_pressure == 0 ) : 
                             globalvars.meteo_data.abs_pressure = None
                         if ( self.cfg.use_bmp085 ):
                             sensor.Sensor.ReadBMP085_temp_in(self)
              
                         globalvars.meteo_data.CalcStatistics()
                         globalvars.meteo_data.LogDataToDB()
                     else:
                         log("Meteo : Error in getting data - status = " +  str(globalvars.meteo_data.status))
                     
                     self.error = False
                 
         
         except IOError,e:
             #raise
             log("ERROR with PCE-FWS20  %s . Will retry ..."  % e)
 #            ret,self.model,self.idd,self.bus = self.Detect()
 #            usbdevice = "/dev/bus/usb/%s/%s" % (self.idd , self.bus )
 #            os.system( "./usbreset %s" % (usbdevice) )
             self.__init__(self.cfg)
             self.error = True
Esempio n. 3
0
    def SetTimeFromWeatherStation(self):
        log("Trying to get time from WH1080. Please wait  ...")
        try:
            read_period = self.ws.get_fixed_block(['read_period'], True)
            if (read_period != 1):
                self.ws._write_byte(self.ws.fixed_format['read_period'][0], 1)

                self.ws._write_byte(self.ws.fixed_format['data_changed'][0],
                                    0xAA)
                # wait for station to clear 'data changed'
                while True:
                    ack = WeatherStation._decode(
                        self.ws._read_fixed_block(0x0020),
                        self.ws.fixed_format['data_changed'])
                    if ack == 0:
                        break
                    log('Write_data waiting for ack')
                    time.sleep(6)
        except:
            pass

        oldpos = None
        while (oldpos == None):
            try:
                oldpos = self.ws.current_pos()
            except:
                log("Error getting station pointer .. retrying")
                time.sleep(1)
                oldpos = None

        found = False
        while (not found):
            try:
                time.sleep(2)
                newpos = self.ws.current_pos()
                if (newpos != oldpos): found = True
            except:
                pass

        thetime = None
        while (thetime == None):
            try:
                thetime = self.ws.get_fixed_block(['date_time'], True)
            except:
                log("Error getting station time .. retrying")
                time.sleep(1)
                thetime = None

        #print thetime
        os.system("sudo date -s '%s'" % thetime)
        log("System time adjusted from WH1080")
Esempio n. 4
0
    def SetTimeFromWeatherStation(self):
        log("Trying to get time from WH1080. Please wait  ...")
        try:
            read_period = self.ws.get_fixed_block(['read_period'],True)
            if ( read_period != 1) :
                self.ws._write_byte(self.ws.fixed_format['read_period'][0],1)
                
                self.ws._write_byte(self.ws.fixed_format['data_changed'][0], 0xAA)
                # wait for station to clear 'data changed'
                while True:
                    ack = WeatherStation._decode(
                        self.ws._read_fixed_block(0x0020), self.ws.fixed_format['data_changed'])
                    if ack == 0:
                        break
                    log('Write_data waiting for ack')
                    time.sleep(6)
        except:
            pass 

        oldpos = None
        while (oldpos==None) :
            try:
                oldpos = self.ws.current_pos()
            except:
                log("Error getting station pointer .. retrying")
                time.sleep(1)
                oldpos = None 
            
        found = False
        while ( not found ):
            try:
                time.sleep(2)
                newpos = self.ws.current_pos()
                if ( newpos != oldpos): found = True
            except:
                pass 
        
        thetime = None
        while ( thetime == None):
            try:
                thetime =  self.ws.get_fixed_block(['date_time'],True)
            except:
                log("Error getting station time .. retrying")
                time.sleep(1)
                thetime = None 
                
        #print thetime
        os.system("sudo date -s '%s'" %  thetime)   
        log("System time adjusted from WH1080")
Esempio n. 5
0
 def __init__(self,cfg ):
     
     self.error = False
     sensor.Sensor.__init__(self,cfg )
     
     ret,self.model,self.idd,self.bus = self.Detect()
     if ( not ret ):
         log("ERROR - No PCE-FWS20 station found. ")
         os.system("sudo ./killswpi.sh")
     else:
         log("Detected : %s" % self.model)
         
     try:    
         self.ws = WeatherStation.weather_station()
     except IOError,e:
         log("Error initializining ws")       
Esempio n. 6
0
    def __init__(self, cfg):

        self.error = False
        sensor.Sensor.__init__(self, cfg)

        ret, self.model, self.idd, self.bus = self.Detect()
        if (not ret):
            log("ERROR - No PCE-FWS20 station found. ")
            os.system("sudo ./killswpi.sh")
        else:
            log("Detected : %s" % self.model)

        try:
            self.ws = WeatherStation.weather_station()
        except IOError, e:
            log("Error initializining ws")
Esempio n. 7
0
def LogData(params, raw_data, sync=None, clear=False):
    logger = logging.getLogger('pywws.LogData')
    # connect to weather station
    ws_type = params.get('config', 'ws type')
    if ws_type:
        params._config.remove_option('config', 'ws type')
        params.set('fixed', 'ws type', ws_type)
    ws_type = params.get('fixed', 'ws type', 'Unknown')
    ws = WeatherStation.weather_station(ws_type=ws_type, params=params)
    fixed_block = CheckFixedBlock(ws, params, logger)
    if not fixed_block:
        logger.error("Invalid data from weather station")
        return 3
    # check for valid weather station type
    if ws.ws_type not in ('1080', '3080'):
        print "Unknown weather station type. Please edit weather.ini"
        print "and set 'ws type' to '1080' or '3080', as appropriate."
        if fixed_block['lux_wm2_coeff'] == 0.0:
            print "Your station is probably a '1080' type."
        else:
            print "Your station is probably a '3080' type."
        sys.exit(1)
    # get sync config value
    if sync is None:
        if fixed_block['read_period'] <= 5:
            sync = int(params.get('config', 'logdata sync', '1'))
        else:
            sync = int(params.get('config', 'logdata sync', '0'))
    # get address and date-time of last complete logged data
    logger.info('Synchronising to weather station')
    range_hi = datetime.max
    range_lo = datetime.min
    last_delay = ws.get_data(ws.current_pos())['delay']
    if last_delay == 0:
        prev_date = datetime.min
    else:
        prev_date = datetime.utcnow()
    for data, last_ptr, logged in ws.live_data(logged_only=(sync > 1)):
        last_date = data['idx']
        logger.debug('Reading time %s', last_date.strftime('%H:%M:%S'))
        if logged:
            break
        if sync < 2 and ws._station_clock:
            err = last_date - datetime.fromtimestamp(ws._station_clock)
            last_date -= timedelta(
                minutes=data['delay'], seconds=err.seconds % 60)
            logger.debug('log time %s', last_date.strftime('%H:%M:%S'))
            last_ptr = ws.dec_ptr(last_ptr)
            break
        if sync < 1:
            hi = last_date - timedelta(minutes=data['delay'])
            if last_date - prev_date > timedelta(seconds=50):
                lo = hi - timedelta(seconds=60)
            elif data['delay'] == last_delay:
                lo = hi - timedelta(seconds=60)
                hi = hi - timedelta(seconds=48)
            else:
                lo = hi - timedelta(seconds=48)
            last_delay = data['delay']
            prev_date = last_date
            range_hi = min(range_hi, hi)
            range_lo = max(range_lo, lo)
            err = (range_hi - range_lo) / 2
            last_date = range_lo + err
            logger.debug('est log time %s +- %ds (%s..%s)',
                         last_date.strftime('%H:%M:%S'), err.seconds,
                         lo.strftime('%H:%M:%S'), hi.strftime('%H:%M:%S'))
            if err < timedelta(seconds=15):
                last_ptr = ws.dec_ptr(last_ptr)
                break
    # go back through stored data, until we catch up with what we've already got
    logger.info('Fetching data')
    Catchup(ws, logger, raw_data, last_date, last_ptr)
    if clear:
        logger.info('Clearing weather station memory')
        ptr = ws.fixed_format['data_count'][0]
        ws.write_data([(ptr, 1), (ptr+1, 0)])
Esempio n. 8
0
    def GetData(self):
        while 1:
            try:
                for data, ptr, ret in self.live_data():

                    if ret:

                        globalvars.meteo_data.status = data["status"]

                        if globalvars.meteo_data.status == 0:

                            globalvars.meteo_data.last_measure_time = datetime.datetime.now(
                            )

                            globalvars.meteo_data.wind_dir = data["wind_dir"]
                            globalvars.meteo_data.idx = data["idx"]

                            globalvars.meteo_data.hum_out = data["hum_out"]
                            globalvars.meteo_data.wind_gust = (
                                float(data["wind_gust"]) * 3.6
                            ) * self.cfg.windspeed_gain + self.cfg.windspeed_offset
                            globalvars.meteo_data.wind_ave = (
                                float(data["wind_ave"]) * 3.6
                            ) * self.cfg.windspeed_gain + self.cfg.windspeed_offset
                            globalvars.meteo_data.rain = float(data["rain"])
                            globalvars.meteo_data.temp_in = float(
                                data["temp_in"])
                            globalvars.meteo_data.delay = float(data["delay"])
                            globalvars.meteo_data.abs_pressure = float(
                                data["abs_pressure"])
                            globalvars.meteo_data.hum_in = float(
                                data["hum_in"])
                            globalvars.meteo_data.temp_out = float(
                                data["temp_out"])
                            wind_dir = data["wind_dir"]
                            if (wind_dir < 16):
                                globalvars.meteo_data.wind_dir = wind_dir * 22.5
                                globalvars.meteo_data.wind_dir_code = WeatherStation.get_wind_dir_text(
                                )[wind_dir]
                            else:
                                globalvars.meteo_data.wind_dir_code = None
                                globalvars.meteo_data.wind_dir_code = None

                            globalvars.meteo_data.illuminance = None
                            globalvars.meteo_data.uv = None

                            # TO REMOVE
                            if (globalvars.meteo_data.abs_pressure == 0):
                                globalvars.meteo_data.abs_pressure = None
                            if (self.cfg.use_bmp085):
                                sensor.Sensor.ReadBMP085_temp_in(self)

                            sensor.Sensor.GetData(self)

                        else:
                            log("Meteo : Error in getting data - status = " +
                                str(globalvars.meteo_data.status))

                        self.error = False

            except IOError, e:
                #raise
                log("ERROR with PCE-FWS20  %s . Will retry ..." % e)
                #            ret,self.model,self.idd,self.bus = self.Detect()
                #            usbdevice = "/dev/bus/usb/%s/%s" % (self.idd , self.bus )
                #            os.system( "./usbreset %s" % (usbdevice) )
                self.__init__(self.cfg)
                self.error = True
Esempio n. 9
0
def main():
    station = WeatherStation.WeatherStation()
    phone = PhoneWeatherService.PhoneWeatherService(station)
    station.Add(phone)
    station.Run()
Esempio n. 10
0
#!/usr/bin/env python
# checkWeather.py
#
# Print current weather conditions.

import sys
sys.path.append('../customLibraries')
import WeatherStation

# Check arguments.
if 1 != len(sys.argv):
  print "Usage:\n  checkWeather.py"
  exit(1)

# Create a WeatherStation object.
ws = WeatherStation.WeatherStation("/home/pi/data/weatherData.csv")

# Get down to business.
ws.fetchData()
ws.printData()
Esempio n. 11
0
    def process(self, live_data, template_file):
        def jump(idx, count):
            while count > 0:
                new_idx = data_set.after(idx + SECOND)
                if new_idx == None:
                    break
                idx = new_idx
                count -= 1
            while count < 0:
                new_idx = data_set.before(idx)
                if new_idx == None:
                    break
                idx = new_idx
                count += 1
            return idx, count == 0

        params = self.params
        if not live_data:
            idx = self.calib_data.before(datetime.max)
            if not idx:
                self.logger.error("No calib data - run Process.py first")
                return
            live_data = self.calib_data[idx]
        pressure_trend_text = WeatherStation.pressure_trend_text
        wind_dir_text = WeatherStation.get_wind_dir_text()
        dew_point = WeatherStation.dew_point
        wind_chill = WeatherStation.wind_chill
        apparent_temp = WeatherStation.apparent_temp
        rain_hour = self._rain_hour
        rain_day = self._rain_day
        pressure_offset = eval(self.params.get('fixed', 'pressure offset'))
        fixed_block = eval(self.params.get('fixed', 'fixed block'))
        # start off with no time rounding
        round_time = None
        # start off in hourly data mode
        data_set = self.hourly_data
        # start off in utc
        time_zone = utc
        # jump to last item
        idx, valid_data = jump(datetime.max, -1)
        if not valid_data:
            self.logger.error("No summary data - run Process.py first")
            return
        data = data_set[idx]
        # open template file file
        tmplt = open(template_file, 'r')
        # do the text processing
        while True:
            line = tmplt.readline()
            if line == '':
                break
            parts = line.split('#')
            for i in range(len(parts)):
                if i % 2 == 0:
                    # not a processing directive
                    if i == 0 or parts[i] != '\n':
                        yield parts[i]
                    continue
                command = shlex.split(parts[i])
                if command == []:
                    # empty command == print a single '#'
                    yield '#'
                elif command[0] in data.keys() + ['calc']:
                    # output a value
                    if not valid_data:
                        continue
                    # format is: key fmt_string no_value_string conversion
                    # get value
                    if command[0] == 'calc':
                        x = eval(command[1])
                        del command[1]
                    else:
                        x = data[command[0]]
                    # adjust time
                    if isinstance(x, datetime):
                        if round_time:
                            x += round_time
                        x = x.replace(tzinfo=utc)
                        x = x.astimezone(time_zone)
                    # convert data
                    if x != None and len(command) > 3:
                        x = eval(command[3])
                    # get format
                    fmt = '%s'
                    if len(command) > 1:
                        fmt = command[1]
                    # write output
                    if x == None:
                        if len(command) > 2:
                            yield command[2]
                    elif isinstance(x, datetime):
                        yield x.strftime(fmt)
                    elif sys.version_info < (2, 5) or not self.use_locale:
                        yield fmt % (x)
                    elif sys.version_info < (2, 7) and '%%' in fmt:
                        yield locale.format_string(fmt.replace('%%', '##'),
                                                   x).replace('##', '%')
                    else:
                        yield locale.format_string(fmt, x)
                elif command[0] == 'monthly':
                    data_set = self.monthly_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'daily':
                    data_set = self.daily_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'hourly':
                    data_set = self.hourly_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'raw':
                    data_set = self.calib_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'live':
                    data_set = self.calib_data
                    idx = datetime.max
                    valid_data = True
                    data = live_data
                elif command[0] == 'timezone':
                    if command[1] == 'utc':
                        time_zone = utc
                    elif command[1] == 'local':
                        time_zone = Local
                    else:
                        self.logger.error("Unknown time zone: %s", command[1])
                        return
                elif command[0] == 'roundtime':
                    if eval(command[1]):
                        round_time = timedelta(seconds=30)
                    else:
                        round_time = None
                elif command[0] == 'jump':
                    prevdata = data
                    idx, valid_data = jump(idx, int(command[1]))
                    data = data_set[idx]
                elif command[0] == 'goto':
                    prevdata = data
                    time_str = command[1]
                    if '%' in time_str:
                        lcl = idx.replace(tzinfo=utc).astimezone(time_zone)
                        time_str = lcl.strftime(time_str)
                    new_idx = DataStore.safestrptime(time_str)
                    new_idx = new_idx.replace(tzinfo=time_zone).astimezone(utc)
                    new_idx = data_set.after(new_idx.replace(tzinfo=None))
                    if new_idx:
                        idx = new_idx
                        data = data_set[idx]
                        valid_data = True
                    else:
                        valid_data = False
                elif command[0] == 'loop':
                    loop_count = int(command[1])
                    loop_start = tmplt.tell()
                elif command[0] == 'endloop':
                    loop_count -= 1
                    if valid_data and loop_count > 0:
                        tmplt.seek(loop_start, 0)
                else:
                    self.logger.error("Unknown processing directive: #%s#",
                                      parts[i])
                    return
        tmplt.close()
        return
Esempio n. 12
0
    def process(self, live_data, template_file):
        def jump(idx, count):
            while count > 0:
                new_idx = data_set.after(idx + SECOND)
                if new_idx == None:
                    break
                idx = new_idx
                count -= 1
            while count < 0:
                new_idx = data_set.before(idx)
                if new_idx == None:
                    break
                idx = new_idx
                count += 1
            return idx, count == 0

        params = self.params
        if not live_data:
            idx = self.calib_data.before(datetime.max)
            if not idx:
                self.logger.error("No calib data - run Process.py first")
                return
            live_data = self.calib_data[idx]
        pressure_trend_text = WeatherStation.pressure_trend_text
        wind_dir_text = WeatherStation.get_wind_dir_text()
        dew_point = WeatherStation.dew_point
        wind_chill = WeatherStation.wind_chill
        apparent_temp = WeatherStation.apparent_temp
        rain_hour = self._rain_hour
        rain_day = self._rain_day
        pressure_offset = eval(self.params.get('fixed', 'pressure offset'))
        #fixed_block = eval(self.params.get('fixed', 'fixed block'))
        # start off with no time rounding
        round_time = None
        # start off in hourly data mode
        data_set = self.hourly_data
        # start off in utc
        time_zone = utc
        # jump to last item
        idx, valid_data = jump(datetime.max, -1)
        if not valid_data:
            self.logger.error("No summary data - run Process.py first")
            return
        data = data_set[idx]
        # open template file file
        tmplt = open(template_file, 'r')
        # do the text processing
        while True:
            line = tmplt.readline()
            if line == '':
                break
            parts = line.split('#')
            for i in range(len(parts)):
                if i % 2 == 0:
                    # not a processing directive
                    if i == 0 or parts[i] != '\n':
                        yield parts[i]
                    continue
                command = shlex.split(parts[i])
                if command == []:
                    # empty command == print a single '#'
                    yield '#'
                elif command[0] in data.keys() + ['calc']:
                    # output a value
                    if not valid_data:
                        continue
                    # format is: key fmt_string no_value_string conversion
                    # get value
                    if command[0] == 'calc':
                        x = eval(command[1])
                        del command[1]
                    else:
                        x = data[command[0]]
                    if command[0] == 'wind_dir' and data['wind_ave'] < 0.3:
                        x = None
                    # adjust time
                    if isinstance(x, datetime):
                        if round_time:
                            x += round_time
                        x = x.replace(tzinfo=utc)
                        x = x.astimezone(time_zone)
                    # convert data
                    if x != None and len(command) > 3:
                        x = eval(command[3])
                    # get format
                    fmt = '%s'
                    if len(command) > 1:
                        fmt = command[1]
                    # write output
                    if x == None:
                        if len(command) > 2:
                            yield command[2]
                    elif isinstance(x, datetime):
                        yield x.strftime(fmt)
                    elif sys.version_info < (2, 5):
                        yield fmt % (x)
                    elif sys.version_info < (2, 7) and '%%' in fmt:
                        yield locale.format_string(
                            fmt.replace('%%', '##'), x).replace('##', '%')
                    else:
                        yield locale.format_string(fmt, x)
                elif command[0] == 'monthly':
                    data_set = self.monthly_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'daily':
                    data_set = self.daily_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'hourly':
                    data_set = self.hourly_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'raw':
                    data_set = self.calib_data
                    idx, valid_data = jump(datetime.max, -1)
                    data = data_set[idx]
                elif command[0] == 'live':
                    data_set = self.calib_data
                    idx = datetime.max
                    valid_data = True
                    data = live_data
                elif command[0] == 'timezone':
                    if command[1] == 'utc':
                        time_zone = utc
                    elif command[1] == 'local':
                        time_zone = Local
                    else:
                        self.logger.error("Unknown time zone: %s", command[1])
                        return
                elif command[0] == 'roundtime':
                    if eval(command[1]):
                        round_time = timedelta(seconds=30)
                    else:
                        round_time = None
                elif command[0] == 'jump':
                    prevdata = data
                    idx, valid_data = jump(idx, int(command[1]))
                    data = data_set[idx]
                elif command[0] == 'goto':
                    prevdata = data
                    time_str = command[1]
                    if '%' in time_str:
                        lcl = idx.replace(tzinfo=utc).astimezone(time_zone)
                        time_str = lcl.strftime(time_str)
                    new_idx = DataStore.safestrptime(time_str)
                    new_idx = new_idx.replace(tzinfo=time_zone).astimezone(utc)
                    new_idx = data_set.after(new_idx.replace(tzinfo=None))
                    if new_idx:
                        idx = new_idx
                        data = data_set[idx]
                        valid_data = True
                    else:
                        valid_data = False
                elif command[0] == 'loop':
                    loop_count = int(command[1])
                    loop_start = tmplt.tell()
                elif command[0] == 'endloop':
                    loop_count -= 1
                    if valid_data and loop_count > 0:
                        tmplt.seek(loop_start, 0)
                else:
                    self.logger.error(
                        "Unknown processing directive: #%s#", parts[i])
                    return
        tmplt.close()
        return
        F = 0.2314 * (1030.81 - pressure)
        LUT = ('A', 'B', 'B', 'B', 'E', 'K', 'N', 'N', 'P', 'P', 'S', 'W', 'W',
               'X', 'X', 'X', 'Z')
    # clip to range of lookup table
    F = min(max(int(F + 0.5), 0), len(LUT) - 1)
    # convert to letter code
    return LUT[F]


def ZambrettiText(letter):
    return forecast_text[letter]


if __name__ == "__main__":
    import WeatherStation
    wind_dir = WeatherStation.get_wind_dir_text()
    for pressure in range(1030, 960, -10):
        for trend_txt in ('S', 'R-S', 'R-W', 'F-W', 'F-S'):
            trend, month = {
                'R-W': (0.2, 1),
                'F-W': (-0.2, 1),
                'R-S': (0.2, 7),
                'F-S': (-0.2, 7),
                'S': (0.0, 7),
            }[trend_txt]
            for wind in (0, 2, 14, None, 4, 12, 6, 10, 8):
                if wind == None:
                    wind_txt = 'calm'
                else:
                    wind_txt = wind_dir[wind]
                print '%4d %4s %4s  %3s' % (pressure, trend_txt, wind_txt,
Esempio n. 14
0
#!/usr/bin/env python
# recordWeather.py
#
# Record the current weather conditions.

import sys
from optparse import OptionParser
sys.path.append('../customLibraries')
import WeatherStation

# Use OptionParser to grab command-line options.
parser = OptionParser()
parser.add_option('-f', '--file', dest='dataFile', help='Write weather data to CSVFILE.', metavar='CSVFILE')
(options, args) = parser.parse_args()

# Supply a default filename, if necessary.
if None == options.dataFile:
  dataFile = '../data/weatherData.csv'
else:
  dataFile = options.dataFile

# Create a WeatherStation object.
ws = WeatherStation.WeatherStation(dataFile=dataFile)

# Get down to business.
ws.fetchData()
ws.recordData()
ws.printData()
Esempio n. 15
0
    else:
        # steady
        F = 0.2314 * (1030.81 - pressure)
        LUT = ('A', 'B', 'B', 'B', 'E', 'K', 'N', 'N', 'P', 'P', 'S', 'W', 'W',
               'X', 'X', 'X', 'Z')
    # clip to range of lookup table
    F = min(max(int(F + 0.5), 0), len(LUT) - 1)
    # convert to letter code
    return LUT[F]

def ZambrettiText(letter):
    return forecast_text[letter]

if __name__ == "__main__":
    import WeatherStation
    wind_dir = WeatherStation.get_wind_dir_text()
    for pressure in range(1030, 960, -10):
        for trend_txt in ('S', 'R-S', 'R-W', 'F-W', 'F-S'):
            trend, month = {
                'R-W' : ( 0.2, 1),
                'F-W' : (-0.2, 1),
                'R-S' : ( 0.2, 7),
                'F-S' : (-0.2, 7),
                'S'   : ( 0.0, 7),
                }[trend_txt]
            for wind in (0, 2, 14, None, 4, 12, 6, 10, 8):
                if wind == None:
                    wind_txt = 'calm'
                else:
                    wind_txt = wind_dir[wind]
                print '%4d %4s %4s  %3s' % (