hi,

i use the PHP-Weather at my Site (http://www.maxglan.at/phpwebsite). How can
I change into Celsius? I send you the file, may you can change it?

many, many thankz!

regards
Bernie

<?php

/*
$Id: phpweather.inc,v 1.1 2001/03/07 20:37:21 mcnaneym Exp $ 
Copyright (c) 
2000, Martin Geisler <[EMAIL PROTECTED]>.
Licensed under the GPL, see the file 
COPYING.
Also see http://www.gimpster.com for updates and further instructions
on how 
to use PHP Weather.
*/

/*
 * Global variables.
 */

/* This stores the version number 
in the variable $version. */
$version = substr('$Revision: 1.1 $', 11, -2);
$last_modified = substr('$Date: 2001/03/07 20:37:21 $', 7, -2);

/* This controls the 
databaseformat PHP Weather uses. Set them both to
   0 to turn database-support off. 
Then PHP Weather will then retrieve
   a new METAR everytime the script is called. */

/* If useDBM is set to 1, the program will create the appropriate 
   files, but the 
owner will be set to the user running the webserver,
   usually nobody. This will fail 
if that user does not have write
   permission to the current directory. */


$dbmMetar = 1;
$dbmTimestamp = 1;


/*
 * Various convenience functions
 */

function 
store_temp($temp,&$destination,$temp_cname,$temp_fname) {
  /*
   * Given a numerical 
temperature $temp in Celsius, coded to tenth of
   * degree, store in 
$destination[$temp_cname], convert to Fahrenheit
   * and store in 
$decoded_metar[$temp_fname]
   * Note: &$destination is call by reference
   * Note: 
$temp is converted to negative if $temp > 100.0 (See
   * Federal Meteorological 
Handbook for groups T, 1, 2 and 4) For
   * example, a temperature of 2.6C and dew 
point of -1.5C would be
   * reported in the body of the report as
   * "03/M01" and 
the TsnT'T'T'snT'dT'dT'd group as "T00261015".
   */

  /* Temperature measured in 
Celsius, coded to tenth of degree */
  $temp = number_format($temp/10, 1);
  if ($temp 
>100.0) { /* first digit = 1 means minus temperature */
     $temp = -($temp - 100.0);
  }
  $destination[$temp_cname] = $temp;
  /* The temperature in Fahrenheit. */
  
$destination[$temp_fname] = number_format($temp * (9/5) + 32, 1);
}


function 
pretty_print_precip($precip_mm, $precip_in) {
  global $strings;
  /* 
   * Returns 
amount if $precip_mm > 0, otherwise "trace" (see Federal
   * Meteorological Handbook 
No. 1 for code groups P, 6 and 7) used in
   * several places, so standardized in one 
function.
   */
  if ($precip_mm>0) {
    $amount = sprintf($strings['mm_inches'], 
$precip_mm, $precip_in);
  } else {
    $amount = $strings['a_trace'];
  }
  return 
sprintf($strings['precip_there_was'], $amount);
}


function store_speed($value, 
$windunit, &$meterspersec, &$knots, &$milesperhour) {
  /*
   * Helper function to 
convert and store speed based on unit.
   * &$meterspersec, &$knots and &$milesperhour 
are passed on
   * reference
   */
  if ($windunit == 'KT') {
    /* The windspeed 
measured in knots: */
    $knots = number_format($value);
    /* The windspeed 
measured in meters per second, rounded to one decimal place: */
    $meterspersec = 
number_format($value * 0.51444, 1);
    /* The windspeed measured in miles per hour, 
rounded to one decimal place: */
    $milesperhour = number_format($value * 
1.1507695060844667, 1);
  } elseif ($windunit == 'MPS') {
    /* The windspeed 
measured in meters per second: */
    $meterspersec = number_format($value);
    /* 
The windspeed measured in knots, rounded to one decimal place: */
    $knots = 
number_format($value / 0.51444, 1);
    /* The windspeed measured in miles per hour, 
rounded to one decimal place: */
    $milesperhour = number_format($value / 0.51444 * 
1.1507695060844667, 1);
  } elseif ($windunit == 'KMH') {
    /* The windspeed 
measured in kilometers per hour: */
    $meterspersec = number_format($value * 1000 / 
3600, 1);
    $knots = number_format($value * 1000 / 3600 / 0.51444, 1);
    /* The 
windspeed measured in miles per hour, rounded to one decimal place: */
    
$milesperhour = number_format($knots * 1.1507695060844667, 1);
  }
}

function 
pretty_print_metar_wap($metar, $location) {
  /*
   * The wap pretty-print function.
  
 *
   * You should pass a metar and a location, eg. 'Aalborg'. That
   * produces 
something like this:
   *
   * Aalborg, 31 min ago
   * Wind: 4.6 mps 
   * Temp: 11 C
   * Clouds: 5/8 - 7/8
   *
   */

  $data = process_metar($metar);
  extract($data);
 
 $minutes_old = round((time() - $time)/60);
  $final = "

<b>$location</b><br /><br />
<b>Wind:</b> $wind_gust_miles_per_hour mph<br />
<b>Temp:</b> $temp_f&#176; F<br />
<b>Visibility: </b>$visibility_miles mi.<br />
<b>Clouds:</b> 
$cloud_layer1_coverage<br />
<b>Humidity:</b> $rel_humidity
";
return $final;
}

function get_metar($station, $always_use_cache = 0) {
  /*
   * Looks in the database, 
and fetches a new metar is nesceary. If
   * $always_use_cache is true, then it 
ignores the timestamp of the
   * METAR and just returns it.
   * 
   * You should 
pass a ICAO station identifier, eg. 'EKYT' for
   * Aalborg, Denmark.
   */


    
$query = "SELECT metar, UNIX_TIMESTAMP(timestamp) FROM mod_metars WHERE station = 
'$station'";
    $result = mysql_query($query);
   if (mysql_num_rows($result)) 
  {
  
     /* found station */
           list($metar, $timestamp) = 
mysql_fetch_row($result);
   }
      if (isset($metar))
      {
      /* found station 
*/
           if ($always_use_cache || $timestamp > time() - 3600) {
         /* We 
have asked explicit for a cached metar, or the metar is still fresh. */
               
 return $metar;
           } else {
             /* We looked in the cache, but the 
metar was too old. */
                 return fetch_metar($station, 0);
               
}
      } else {
       /* The station is new - we fetch a new METAR */
               
 return fetch_metar($station, 1);
       }
}


function fetch_metar($station, $new) {
 
 /*
   * Fetches a new metar from weather.noaa.gov. If the $new variable
   * is true, 
the metar is inserted, else it will replace the old
   * metar.
   */
  $metar = "";
  
/* Retrieves the METAR from weather.noaa.gov and insert the data
   * into the 
database. If $new is true, insert the metar, else just
   * update. Returns the METAR.
   */
  $station = strtoupper($station);

  /* We use the @file notation, because it 
might fail. */
  $file  = 
@file("http://weather.noaa.gov/pub/data/observations/metar/stations/$station.TXT");
  
/* Here we test to see if we actually got a meter. */
  if (is_array($file)) {
    
list($i, $date) = each($file);
    $date = trim($date);
    while (list($i, $line) = 
each($file)) {
      $metar .= ' ' . trim($line);
    }

    $metar = str_replace('  
', ' ', $metar);
    
    /* The date is in the form 2000/10/09 14:50 UTC. This 
seperates
       the different parts. */
    $date_parts = explode(':', strtr($date, 
'/ ', '::'));
    $date_unixtime = gmmktime($date_parts[3], $date_parts[4], 0, 
$date_parts[1], $date_parts[2], $date_parts[0]);

    /* It might seam strange, that 
we make a local date, but MySQL
       expects a local when we insert the METAR. The 
same applies for
       the other $date = date('Y/m/d H:i') statements. */
    $date = 
date('Y/m/d H:i', $date_unixtime);

    if (!ereg('[0-9]{6}Z', $metar)) {
      /* 
Some reports dont even have a time-part, so we insert the
       * current time. This 
might not be the time of the report, but
       * it was broken anyway :-) */
      
$metar = gmdate('dHi', $date_unixtime) . 'Z ' . $metar;
    }
    
    if 
($date_unixtime < (time() - 3300)) {
      /* The timestamp in the metar is more than 
55 minutes old.  We
       adjust the timestamp, so that we won't try to fetch a new
  
    METAR within the next 5 minutes. After 5 minutes, the
  timestamp will again be 
more than 1 hour old. */
      $date = date('Y/m/d H:i', time() - 3300);
    }
    
  
} else {
    /* If we end up here, it means that there was no file, we then set
       
the metar to and empty string and. We set the date to time() -
       3000 to give the 
server 10 minutes of peace. If the file is
       unavailable, we don't want to stress 
the server. */
    $metar = '';
    $date = date('Y/m/d H:i', time() - 3000);
  }


   
 if ($new) {
      /* Insert the new record */
      $query = "INSERT INTO mod_metars 
SET station = '$station', metar = '$metar', timestamp = '$date'";
    } else {
      
/* Update the old record */
      $query = "UPDATE mod_metars SET metar = '$metar', 
timestamp = '$date' WHERE station = '$station'";
    }
    mysql_query($query);


  
return $metar;
}

function process_metar($metar) {
/* initialization */

global 
$strings, $wind_dir_text_short_array, $wind_dir_text_array, $cloud_condition_array, 
$weather_array;
$decoded_metar['temp_visibility_miles'] = "";
$cloud_layers = 0;
$decoded_metar['remarks'] = "";

  $cloud_coverage = array('SKC' => '0',
              
        'CLR' => '0',
                          'VV'  => '8/8',
                       
 'FEW' => '1/8 - 2/8',
                          'SCT' => '3/8 - 4/8',
                
          'BKN' => '5/8 - 7/8',
                          'OVC' => '8/8');
  
  
$decoded_metar['metar'] = $metar;
  $parts = explode(' ', $metar);
  $num_parts = 
count($parts);
  for ($i = 0; $i < $num_parts; $i++) {
    $part = $parts[$i];

    if 
(ereg('RMK|TEMPO|BECMG', $part)) {
      /* The rest of the METAR is either a remark 
or temporary
         information. We skip the rest of the METAR. */
      
$decoded_metar['remarks'] .= ' ' . $part;
      break;
    } elseif ($part == 'METAR') 
{
      /*
       * Type of Report: METAR
       */
      $decoded_metar['type'] = 
'METAR';
    } elseif ($part == 'SPECI') {
      /*
       * Type of Report: SPECI
    
   */
      $decoded_metar['type'] = 'SPECI';
    } elseif (ereg('^[A-Z]{4}$', $part) 
&& ! isset($decoded_metar['station']))  {
      /*
       * Station Identifier
       
*/
      $decoded_metar['station'] = $part;
    } elseif 
(ereg('([0-9]{2})([0-9]{2})([0-9]{2})Z', $part, $regs)) {
      /*
       * Date and 
Time of Report
       * We return a standard Unix UTC/GMT timestamp suitable for
      
 * gmdate()
       * There has been a report about the time beeing wrong. If you
      
 * experience this, then change the next line. You should
       * add/subtract some 
hours to $regs[2], e.g. if all your times
       * are 960 minutes off (16 hours) then 
add 16 to $regs[2].
       */
      $decoded_metar['time'] = gmmktime($regs[2], 
$regs[3], 0, gmdate('m'), $regs[1], gmdate('Y'));
    } elseif 
(ereg('(AUTO|COR|RTD|CC[A-Z]|RR[A-Z])', $part, $regs)) {
      /*
       * Report 
Modifier: AUTO, COR, CCx or RRx
       */
      $decoded_metar['report_mod'] = 
$regs[1];
    } elseif (ereg('([0-9]{3}|VRB)([0-9]{2,3}).*(KT|MPS|KMH)', $part, 
$regs)) {
      /* Wind Group */
      $windunit = $regs[3];  /* do ereg in two parts 
to retrieve unit first */
      /* now do ereg to get the actual values */
      
ereg("([0-9]{3}|VRB)([0-9]{2,3})(G([0-9]{2,3})?$windunit)", $part, $regs);
      if 
($regs[1] == 'VRB') {
 $decoded_metar['wind_deg'] = $strings['wind_vrb_long'];
        
$decoded_metar['wind_dir_text'] = $strings['wind_vrb_long'];
   
$decoded_metar['wind_dir_text_short'] = $strings['wind_vrb_short'];
      } else {
    
 $decoded_metar['wind_deg'] = $regs[1];
 $decoded_metar['wind_dir_text'] = 
$wind_dir_text_array[round($regs[1]/22.5)];
  $decoded_metar['wind_dir_text_short'] = 
$wind_dir_text_short_array[round($regs[1]/22.5)];
      }
      store_speed($regs[2],
 
           $windunit,
             $decoded_metar['wind_meters_per_second'],
          
    $decoded_metar['wind_knots'],
                  
$decoded_metar['wind_miles_per_hour']
                  );

      if (isset($regs[4])) 
{
     /* We have a report with information about the gust.
      First we have the 
gust measured in knots: */
        store_speed($regs[4],$windunit,
          
$decoded_metar['wind_gust_meters_per_second'],
          
$decoded_metar['wind_gust_knots'],
          
$decoded_metar['wind_gust_miles_per_hour']);
      }
    } elseif 
(ereg('^([0-9]{3})V([0-9]{3})$', $part, $regs)) {
      /*
       * Variable 
wind-direction
       */
      $decoded_metar['wind_var_beg'] = $regs[1];
      
$decoded_metar['wind_var_end'] = $regs[2];
    } elseif ($part == 9999) {
      /* A 
strange value. When you look at other pages you see it
      interpreted like this 
(where I use > to signify 'Greater
       than'): */
      
$decoded_metar['visibility_miles'] = '>7';
      $decoded_metar['visibility_km']    = 
'>11.3';
    } elseif(ereg('^([0-9]{4})$', $part, $regs)) {
      /* 
       * 
Visibility in meters (4 digits only)
       */
      /* The visibility measured in 
kilometers, rounded to one decimal place. */
      $decoded_metar['visibility_km'] = 
number_format($regs[1]/1000, 1);
      /* The visibility measured in miles, rounded to 
one decimal place. */
      $decoded_metar['visibility_miles'] = number_format( 
($regs[1]/1000) / 1.609344, 1);
    } elseif (ereg('^[0-9]$', $part)) {
      /*
      
 * Temp Visibility Group, single digit followed by space
       */
      
$decoded_metar['temp_visibility_miles'] = $part;
    } elseif (ereg('^M?(([0-9]?)[ 
]?([0-9])(/?)([0-9]*))SM$', $decoded_metar['temp_visibility_miles'].' '.$parts[$i], 
$regs)) {
      /*
       * Visibility Group
       */
      if ($regs[4] == '/') {
   
    $vis_miles = $regs[2] + $regs[3]/$regs[5];
      } else {
      $vis_miles = 
$regs[1];
      }
      if ($regs[0][0] == 'M') {
 /* The visibility measured in 
miles, prefixed with < to indicate 'Less than' */
        
$decoded_metar['visibility_miles'] = '<' . number_format($vis_miles, 1);
       /* The 
visibility measured in kilometers. The value is rounded
    to one decimal place, 
prefixed with < to indicate 'Less than' */
    $decoded_metar['visibility_km']    = 
'<' . number_format($vis_miles * 1.609344, 1);
      } else {
     /* The visibility 
measured in mile.s */
        $decoded_metar['visibility_miles'] = 
number_format($vis_miles, 1);
     /* The visibility measured in kilometers, rounded 
to one decimal place. */
     $decoded_metar['visibility_km']    = 
number_format($vis_miles * 1.609344, 1);
      }
    } elseif ($part == 'CAVOK') {
    
  /* CAVOK: Used when the visibility is greather than 10
         kilometers, the 
lowest cloud-base is at 5000 feet and there
         is no significant weather. */
    
  $decoded_metar['visibility_km']    = '>10';
      $decoded_metar['visibility_miles'] 
= '>6.2';
      $decoded_metar['cloud_layer1_condition'] = 'CAVOK';
    } elseif 
(ereg('^R([0-9][0-9][RLC]?)/([MP]?[0-9]{4})V?(P?[0-9]{4})?F?T?$', $part, $regs)) {
    
  $decoded_metar['runway_nr'] = $regs[1];
      if ($regs[3]) {
    /* We have both 
min and max visibility. */
     $prefix = '';
  if ($regs[2][0] == 'M') {
        /* 
Less than. */
       $prefix = '<';
         $regs[2] = substr($regs[2], 1);
      }
  
    $decoded_metar['runway_vis_min_ft']    = $prefix . number_format($regs[2]);
    
$decoded_metar['runway_vis_min_meter'] = $prefix . number_format($regs[2] * 0.3048);

 
 $prefix = '';
  if ($regs[3][0] == 'P') {
        /* Greather than. */
   $prefix = 
'>';
         $regs[3] = substr($regs[3], 1);
      }
      
$decoded_metar['runway_vis_max_ft']    = $prefix . number_format($regs[3]);
    
$decoded_metar['runway_vis_max_meter'] = $prefix . number_format($regs[3] * 0.3048);
  
   
      } else {
      /* We only have a single visibility. */
        $prefix = '';
  if ($regs[2][0] == 'M') {
        $prefix = '<';
         $regs[2] = 
substr($regs[2], 1);
      } elseif ($regs[2][0] == 'P') {
          $prefix = '>';
   
      $regs[2] = substr($regs[2], 1);
      }
      $decoded_metar['runway_vis_ft']    
= $prefix . number_format($regs[2]);
        $decoded_metar['runway_vis_meter'] = 
$prefix . number_format($regs[2] * 0.3048);
      }
    } elseif 
(ereg('^(-|\+|VC)?(TS|SH|FZ|BL|DR|MI|BC|PR|RA|DZ|SN|SG|GR|GS|PE|IC|UP|BR|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS)+$',
 $part)) {
      /*
       * Current weather-group
       */ 
      if ($part[0] == 
'-') {
      /* A light phenomenon */
       $decoded_metar['weather'] .= 
$strings['light'];
        $part = substr($part, 1);
      } elseif ($part[0] == '+') 
{
   /* A heavy phenomenon */
       $decoded_metar['weather'] .= $strings['heavy'];
  
      $part = substr($part, 1);
      } elseif ($part[0].$part[1] == 'VC') {
 /* 
Proximity Qualifier */
      $decoded_metar['weather'] .= $strings['nearby'];
       
$part = substr($part, 2);
      } else {
        /* no intensity code => moderate 
phenomenon */
        $decoded_metar['weather'] .= $strings['moderate'];
      }
      

      while ($bite = substr($part, 0, 2)) {
  /* Now we take the first two letters 
and determine what they
      mean. We append this to the variable so that we 
gradually
      build up a phrase. */
       $decoded_metar['weather'] .= 
$weather_array[$bite];
    /* Here we chop off the two first letters, so that we can 
take
    a new bite at top of the while-loop. */
     $part = substr($part, 2);
      
}
    } elseif (ereg('(SKC|CLR)', $part, $regs)) {
      /*
       * 
Cloud-layer-group.
       * There can be up to three of these groups, so we store them 
as
       * cloud_layer1, cloud_layer2 and cloud_layer3.
       */
      
$cloud_layers++;
      /* Again we have to translate the code-characters to a
      
meaningful string. */
      $decoded_metar['cloud_layer'. $cloud_layers.'_condition']  
= $cloud_condition_array[$regs[1]];
      
$decoded_metar['cloud_layer'.$cloud_layers.'_coverage']    = 
$cloud_coverage_array[$regs[1]];
    } elseif 
(ereg('^(VV|FEW|SCT|BKN|OVC)([0-9]{3})(CB|TCU)?$', $part, $regs)) {
      /* We have 
found (another) a cloud-layer-group. There can be up
  to three of these groups, so we 
store them as cloud_layer1,
    cloud_layer2 and cloud_layer3. */
      
$cloud_layers++;
      /* Again we have to translate the code-characters to a 
meaningful string. */
      if ($regs[1] == 'OVC') {
    $clouds_str_temp = '';
      
} else {
  $clouds_str_temp = $strings['clouds'];
      }
      if ($regs[3] == 'CB') 
{
   /* cumulonimbus (CB) clouds were observed. */
  
$decoded_metar['cloud_layer'.$cloud_layers.'_condition'] =
       
$cloud_condition_array[$regs[1]] . $strings['clouds_cb'];
      } elseif ($regs[3] == 
'TCU') {
       /* towering cumulus (TCU) clouds were observed. */
     
$decoded_metar['cloud_layer'.$cloud_layers.'_condition'] =
       
$cloud_condition_array[$regs[1]] . $strings['clouds_tcu'];
      } else {
    
$decoded_metar['cloud_layer'.$cloud_layers.'_condition'] =
       
$cloud_condition_array[$regs[1]] . $clouds_str_temp;
      }
      
$decoded_metar['cloud_layer'.$cloud_layers.'_coverage']    = 
$cloud_coverage[$regs[1]];
      
$decoded_metar['cloud_layer'.$cloud_layers.'_altitude_ft'] = $regs[2] *100;
      
$decoded_metar['cloud_layer'.$cloud_layers.'_altitude_m']  = round($regs[2] * 30.48);
 
   } elseif (ereg('^(M?[0-9]{2})/(M?[0-9]{2})?$', $part, $regs)) {
      /*
       * 
Temperature/Dew Point Group
       * The temperature and dew-point measured in 
Celsius.
       */
      $decoded_metar['temp_c'] = number_format(strtr($regs[1], 'M', 
'-'));
      $decoded_metar['dew_c']  = number_format(strtr($regs[2], 'M', '-'));
     
 /* The temperature and dew-point measured in Fahrenheit, rounded to the nearest 
degree. */
      $decoded_metar['temp_f'] = round(strtr($regs[1], 'M', '-') * (9/5) + 
32);
      $decoded_metar['dew_f']  = round(strtr($regs[2], 'M', '-') * (9/5) + 32);
  
  } elseif(ereg('A([0-9]{4})', $part, $regs)) {
      /*
       * Altimeter
       * 
The pressure measured in inHg
       */
      $decoded_metar['altimeter_inhg'] = 
number_format($regs[1]/100, 2);
      /* The pressure measured in mmHg, hPa and atm */
      $decoded_metar['altimeter_mmhg'] = number_format($regs[1] * 0.254, 1);
      
$decoded_metar['altimeter_hpa']  = number_format($regs[1] * 0.33863881578947);
      
$decoded_metar['altimeter_atm']  = number_format($regs[1] * 3.3421052631579e-4, 3);
   
 } elseif(ereg('Q([0-9]{4})', $part, $regs)) {
      /*
       * Altimeter
       * 
This is strange, the specification doesnt say anything about
       * the Qxxxx-form, 
but it's in the METARs.
       */
      /* The pressure measured in hPa */
      
$decoded_metar['altimeter_hpa']  = number_format($regs[1]);
      /* The pressure 
measured in mmHg, inHg and atm */
      $decoded_metar['altimeter_mmhg'] = 
number_format($regs[1] * 0.7500616827, 1);
      $decoded_metar['altimeter_inhg'] = 
number_format($regs[1] * 0.0295299875, 2);
      $decoded_metar['altimeter_atm']  = 
number_format($regs[1] * 9.869232667e-4, 3);
    } elseif 
(ereg('^T([0-9]{4})([0-9]{4})', $part, $regs)) {
      /*
       * Temperature/Dew 
Point Group, coded to tenth of degree.
       * The temperature and dew-point measured 
in Celsius.
       */
      store_temp($regs[1],$decoded_metar,'temp_c','temp_f');
    
  store_temp($regs[2],$decoded_metar,'dew_c','dew_f');
    } elseif 
(ereg('^T([0-9]{4}$)', $part, $regs)) {
      
store_temp($regs[1],$decoded_metar,'temp_c','temp_f');
    } elseif 
(ereg('^1([0-9]{4}$)', $part, $regs)) {
      /*
       * 6 hour maximum temperature 
Celsius, coded to tenth of degree
       */
      
store_temp($regs[1],$decoded_metar,'temp_max6h_c','temp_max6h_f');
    } elseif 
(ereg('^2([0-9]{4}$)', $part, $regs)) {
      /*
       * 6 hour minimum temperature 
Celsius, coded to tenth of degree
       */
      
store_temp($regs[1],$decoded_metar,'temp_min6h_c','temp_min6h_f');
    } elseif 
(ereg('^4([0-9]{4})([0-9]{4})$', $part, $regs)) {
      /*
       * 24 hour maximum 
and minimum temperature Celsius, coded to
       * tenth of degree
       */
      
store_temp($regs[1],$decoded_metar,'temp_max24h_c','temp_max24h_f');
      
store_temp($regs[2],$decoded_metar,'temp_min24h_c','temp_min24h_f');
    } 
elseif(ereg('^P([0-9]{4})', $part, $regs)) {
      /*
       * Precipitation during 
last hour in hundredths of an inch
       * (store as inches)
       */
      
$decoded_metar['precip_in'] = number_format($regs[1]/100, 2);
      
$decoded_metar['precip_mm'] = number_format($regs[1]*0.254, 2);
    } 
elseif(ereg('^6([0-9]{4})', $part, $regs)) {
      /*
       * Precipitation during 
last 3 or 6 hours in hundredths of an
       * inch  (store as inches)
       */
      
$decoded_metar['precip_6h_in'] = number_format($regs[1]/100, 2);
      
$decoded_metar['precip_6h_mm'] = number_format($regs[1]*0.254, 2);
    } 
elseif(ereg('^7([0-9]{4})', $part, $regs)) {
      /*
       * Precipitation during 
last 24 hours in hundredths of an inch
       * (store as inches)
       */
      
$decoded_metar['precip_24h_in'] = number_format($regs[1]/100, 2);
      
$decoded_metar['precip_24h_mm'] = number_format($regs[1]*0.254, 2);
    } 
elseif(ereg('^4/([0-9]{3})', $part, $regs)) {
      /*
       * Snow depth in inches
  
     */
      $decoded_metar['snow_in'] = number_format($regs[1]);
      
$decoded_metar['snow_mm'] = number_format($regs[1] * 25.4);
    } else {
      /*
     
  * If we couldn't match the group, we assume that it was a
       * remark.
       */
      $decoded_metar['remarks'] .= ' ' . $part;
    }
  }
  /*
   * Relative humidity
 
  */
  $decoded_metar['rel_humidity'] = number_format(100 * 
    (
     610.710701 + 
 
    44.4293573 * $decoded_metar['dew_c'] +
     1.41696846 * 
pow($decoded_metar['dew_c'], 2) + 
     0.0274759545 * pow($decoded_metar['dew_c'], 3) 
+ 
     2.61145937E-4 * pow($decoded_metar['dew_c'], 4) + 
     2.85993708E-6 * 
pow($decoded_metar['dew_c'], 5)
     )
    /
    (
     610.710701 + 
     44.4293573 
* $decoded_metar['temp_c'] +
     1.41696846 * pow($decoded_metar['temp_c'], 2) + 
    
 0.0274759545 * pow($decoded_metar['temp_c'], 3) + 
     2.61145937E-4 * 
pow($decoded_metar['temp_c'], 4) + 
     2.85993708E-6 * pow($decoded_metar['temp_c'], 
5)
     ), 1);
                                  
  return $decoded_metar;
}
 
function update_metars_db() {
  /* Updates all the metars in the database. You should 
use it like
   * this:
   *
   * <?php
   * include('phpweather.inc');
   * 
register_shutdown_function('update_metars_db');
   * ?>
   *  
   * This will update 
all the metars *after* the script has
   * finished. This means that the user won't 
know that PHP is still
   * running, and most important, they won't have to wait when 
the
   * script fetches a new METAR, because it is done afterwards.
   *
   * You can 
pass en extra argument to get_metar(), so that it never
   * tries to fetch a new 
meter. This ensures that the page will load
   * quickly, but the weather might be a 
little old. If the user the
   * refreshed the page, the new weather will be shown.
   
*/

    $query = "SELECT station FROM mod_metars";
    $result = mysql_query($query);
 
   while (list($station) = mysql_fetch_row($result)) {
      fetch_metar($station, 0);
    }
}

?>
<?php
/*        $Id: phpweather.php,v 1.1 2001/03/07 20:37:21 mcnaneym Exp $     */
/* 
Be sure to check out the newest version from http://www.gimpster.com */

       
include('/home/dream/public_html/members/maxglan/phpwebsite/plug-ins/phpweather/phpweather.inc');


     $metar = get_metar('LOWS');
    $box_content = pretty_print_metar_wap($metar, 
'Salzburg, Maxglan');
    register_shutdown_function('update_metars_db');

?>

Reply via email to