X-Git-Url: http://gb7djk.dxcluster.net/gitweb/gitweb.cgi?a=blobdiff_plain;f=loop.pl;h=02a463a7d3f1569eda6f6065b4a6cf4e1007e2ad;hb=9b87b2428a5050fb2fd2803d0d568ca916365738;hp=ef0c4e031a5c37150046cd13981e8047b2b5c265;hpb=34fb2f9bb6432b6dffe2f79fe6c4e31801565aad;p=dweather.git diff --git a/loop.pl b/loop.pl index ef0c4e0..02a463a 100755 --- a/loop.pl +++ b/loop.pl @@ -3,17 +3,52 @@ use strict; use v5.10.1; -use DBI; +use Mojolicious::Lite; use Serial; use Mojo::IOLoop; use Mojo::IOLoop::Stream; - +use Mojo::Transaction::WebSocket; +#use Mojo::JSON qw(decode_json encode_json); +use JSON; +use Debug; +use SMGLog; +use Math::Round qw(nearest); +use File::Copy; +use Data::Random qw(rand_chars); +use IO::File; + +use constant pi => 3.14159265358979; + +my $randomfn = '/dev/urandom'; my $devname = "/dev/davis"; +my $datafn = ".loop_data"; +my $dataf; + +my $poll_interval = 2.5; +my $rain_mult = 0.2; # 0.1 or 0.2 mm or 0.01 inches my $tid; my $rid; -my $count; +our $did; +my $nlcount; my $state = "ready"; my $buf; +my $dbg; +our $ser; # the serial port Mojo::IOLoop::Stream +our $ob; # the Serial Port filehandle +my $last_min_h; +my $last_hour_h; + +our $json = JSON->new->canonical(1); +our $WS = {}; # websocket connections + +our $ld = {}; +our @last10minsr = (); +our @last5daysh = (); +our $windmins = 2; # no of minutes of wind data for the windrose +our $histdays = 5; # no of days of (half)hour data to search for main graph +our $updatepermin = 60 / 2.5; # no of updates per minute + +our $loop_count; # how many LOOPs we have done, used as start indicator our @crc_table = ( 0x0, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, @@ -60,34 +95,142 @@ $bar_trend{0} = "Steady"; $bar_trend{20} = "Rising Slowly"; $bar_trend{60} = "Rising Rapidly"; -#$SIG{TERM} = $SIG{INT} = sub {Mojo::IOLoop->reset if Mojo::IOLoop->is_running && !$DB::VERSION}; +our $ending = 0; + +$SIG{TERM} = $SIG{INT} = sub {$ending = 1; Mojo::IOLoop->stop;}; +$SIG{HUP} = 'IGNORE'; + + +# WebSocket weather service +websocket '/weather' => sub { + my $c = shift; + my $msg = shift; + my $tx = $c->tx; + + # Opened + app->log->debug('WebSocket opened.'); + dbg 'WebSocket opened' if isdbg 'chan'; + $WS->{$tx} = $tx; + + # send historical data + $c->send($ld->{lasthour_h}) if exists $ld->{lasthour_h}; + $c->send($ld->{lastmin_h}) if exists $ld->{lastmin_h}; + + # disable timeout + $c->inactivity_timeout(3615); + + # Incoming message + $c->on( + message => sub { + my ($c, $msg) = @_; + dbg "websocket: text $msg" if isdbg 'chan'; + }, + json => sub { + my ($c, $msg) = @_; + dbg "websocket: json $msg" if isdbg 'chan'; + } + ); + + # Closed + $c->on(finish => sub { + my ($c, $code, $reason) = @_; + app->log->debug("WebSocket closed with status $code."); + dbg "websocket closed with status $code" if isdbg 'chan'; + delete $WS->{$tx}; + }); +}; + +get '/' => {template => 'index'}; + + +dbginit(); +if (@ARGV) { + dbgadd(@ARGV); +} +dbgadd('chan'); + +dbg '***'; +dbg "*** starting $0"; +dbg '***'; + +read_ld(); + +my $tnow = time; +my $dayno = int ($tnow/86400); +for (my $i = 0-$histdays; $i < 0; ++$i ) { + push @last5daysh, grab_history(SMGLog->new("day"), "h", $tnow-(86400*$histdays), $dayno+$i+1); +} +@last10minsr = map {my ($t, $js) = split(/\s/, $_, 2); $js} grab_history(SMGLog->new("debug"), "r", $tnow-(60*$windmins), $dayno); +dbg sprintf("last5days = %d last10mins = %d", scalar @last5daysh, scalar @last10minsr); + +sysopen(R, $randomfn, 0) or die "cannot open $randomfn $!\n"; +my $rs; +sysread(R, $rs, 8) or die "not enough randomness available\n"; +close R; + +app->secrets([qw(Here's something that's really seakrett), $rs]); + +our $dlog = SMGLog->new("day"); +$did = Mojo::IOLoop->recurring(1 => sub {$dlog->flushall}); + +dbg "before next tick"; +Mojo::IOLoop->next_tick(sub { loop() }); +dbg "before app start"; +app->start; +dbg "after app start"; + +doclose(); + +write_ld(); +$dataf->close if $dataf; +undef $dataf; + -my $s = do_open($devname); -start_loop(); +# move all the files along one +cycle_loop_data_files(); -Mojo::IOLoop->start unless Mojo::IOLoop->is_running; +dbg '***'; +dbg "*** ending $0 (\$ending = $ending)"; +dbg '***'; exit 0; +################################################################################## + +sub loop +{ + dbg "last_min: " . scalar gmtime($ld->{last_min}); + dbg "last_hour: " . scalar gmtime($ld->{last_hour}); + + $ser = doopen($devname); + start_loop() if $ser; +} + + + sub on_read { - my ($str, $d) = @_; + my ($ser, $d) = @_; $buf .= $d; $d =~ s/([\%\x00-\x1f\x7f-\xff])/sprintf("%%%02X", ord($1))/eg; -# say "read added '$d' buf lth=" . length $buf; + dbg "read added '$d' buf lth=" . length $buf if isdbg 'raw'; if ($state eq 'waitnl' && $buf =~ /[\cJ\cM]+/) { + dbg "Got \\n" if isdbg 'state'; + Mojo::IOLoop->remove($tid) if $tid; undef $tid; undef $buf; - $s->write("LOOP 1\n"); + $nlcount = 0; + $ser->write("LPS 1 1\n"); chgstate("waitloop"); } elsif ($state eq "waitloop") { if ($buf =~ /\x06/) { + dbg "Got ACK 0x06" if isdbg 'state'; chgstate('waitlooprec'); undef $buf; } } elsif ($state eq 'waitlooprec') { if (length $buf >= 99) { - say "got loop record\n"; + dbg "got loop record" if isdbg 'chan'; chgstate(''); process($buf); undef $buf; @@ -97,120 +240,377 @@ sub on_read sub start_loop { - say "writing \\n"; - $s->write("\n"); - $tid = Mojo::IOLoop->timer(0.6 => sub {say "writing \\n"; $s->write("\n")}); + $nlcount = 1; + dbg "start_loop writing $nlcount \\n" if isdbg 'state'; + $ser->write("\n"); + Mojo::IOLoop->remove($tid) if $tid; + undef $tid; + $tid = Mojo::IOLoop->recurring(0.6 => sub { + if (++$nlcount > 10) { + doclose(); + return; + } + dbg "writing $nlcount \\n" if isdbg 'state'; + $ser->write("\n"); + }); chgstate("waitnl"); } sub chgstate { - say "state '$state' -> '$_[0]'"; + dbg "state '$state' -> '$_[0]'" if isdbg 'state'; $state = $_[0]; } -sub do_open +my $closing; + +sub doopen { my $name = shift; - my $ob = Serial->new($name, 19200) || die "$name $!\n"; - say "streaming $name fileno(", fileno($ob), ")"; - my $str = Mojo::IOLoop::Stream->new($ob); - $str->on(error=>sub {say "serial $_[1]"; undef $s; Mojo::IOLoop->reset;}); - $str->on(close=>sub {say "serial closing"; undef $s; Mojo::IOLoop->reset;}); - $str->on(timeout=>sub {say "serial timeout";}); - $str->on(read=>sub {on_read(@_)}); - $str->start; - $rid = Mojo::IOLoop->recurring(2.5 => sub {start_loop() if !$state || $state eq "waitnl";}); + $ob = Serial->new($name, 19200) || die "$name $!\n"; + dbg "streaming $name fileno(" . fileno($ob) . ")" if isdbg 'chan'; + + my $ser = Mojo::IOLoop::Stream->new($ob); + $ser->on(error=>sub {dbg "error serial $_[1]"; doclose();}); + $ser->on(close=>sub {dbg "event close"; doclose();}); + $ser->on(timeout=>sub {dbg "event serial timeout"; doclose();}); + $ser->on(read=>sub {on_read(@_)}); + $ser->start; + + $rid = Mojo::IOLoop->recurring($poll_interval => sub { + start_loop() if !$state; + }); + + chgstate(''); + $nlcount = 0; + + return $ser; +} - return $str; +sub doclose +{ + return if $closing++; + + dbg "serial port closing" if $ser || $ob; + if ($ser) { + $ser->stop; + $ser->close; + undef $ser; + } + if ($ob) { + $ob->close(); + undef $ob; + } + Mojo::IOLoop->remove($tid) if $tid; + undef $tid; + Mojo::IOLoop->remove($rid) if $rid; + undef $rid; + + if (Mojo::IOLoop->is_running && $ending == 0) { + Mojo::IOLoop->delay( + sub { + my $delay = shift; + Mojo::IOLoop->timer(5 => $delay->begin); + dbg "Waiting 5 seconds before opening serial port"; + }, + + sub { + dbg "Opening Serial port"; + $ser = doopen($devname); + $closing = 0; + } + )->wait; + } + chgstate(''); + $nlcount = 0; } +my @min; +my @hour; + sub process { my $blk = shift; my $loo = substr $blk,0,3; unless ( $loo eq 'LOO') { - say "Block invalid loo -> $loo"; return; + dbg "Block invalid loo -> $loo" if isdbg 'chan'; return; } - my $t; - my %hsh; - + my $tmp; + my $temp; + my $rain; + my %h; - #$hsh{'next_rec'} = unpack("s", substr $blk,5,2); - - $hsh{'Barometric_Trend'} = unpack("C", substr $blk,3,1); - $hsh{'Barometric_Trend_txt'} = $bar_trend{$hsh{'Barometric_Trend'}}; - $t = unpack("s", substr $blk,7,2) / 1000; - # $hsh{'Barometric_Press_hg'} = $t; - $hsh{'Barometric_Press_mb'} = sprintf("%.2f",$t*33.8637526); + my $crc_calc = CRC_CCITT($blk); + if ($crc_calc==0) { - $t = unpack("s", substr $blk,9,2) / 10; - # $hsh{'Air_Temp_Inside_f'} = $t; - $hsh{'Air_Temp_Inside_c'} = sprintf("%.1f",($t - 32) * 5/9); - my $tf = unpack("s", substr $blk,12,2) / 10; - # $hsh{'Air_Temp_Outside_f'} = $tf; - $hsh{'Air_Temp_Outside_c'} = sprintf("%.1f",($tf - 32) * 5/9); + # Common ones + $tmp = unpack("s", substr $blk,7,2) / 1000; + $h{Pressure} = nearest(0.1, in2mb($tmp)); - $hsh{'Wind_Speed_mph'} = unpack("C", substr $blk,14,1); - # $hsh{'Wind_Speed_mps'} = sprintf("%.1f",$hsh{'Wind_Speed_mph'}*0.44704); - $hsh{'Wind_Speed_10min_Avg_mph'} = unpack("C", substr $blk,15,1); - # $hsh{'Wind_Speed_10min_Avg_mps'} = sprintf("%.1f",$hsh{'Wind_Speed_10min_Avg_mph'}*0.44704); - $hsh{'Wind_Dir'} = unpack("s", substr $blk,16,2); + $tmp = unpack("s", substr $blk,9,2) / 10; + $h{Temp_In} = nearest(0.1, f2c($tmp)); + $temp = nearest(0.1, f2c(unpack("s", substr $blk,12,2) / 10)); + $h{Temp_Out} = $temp; + if ($temp > 75 || $temp < -75) { + dbg "LOOP Temperature out of range ($temp), record ignored"; + return; + } - $hsh{'Humidity_Outside'} = unpack("C", substr $blk,33,1); - $hsh{'Humidity_Inside'} = unpack("C", substr $blk,11,1); - $hsh{'Dew_Point'} = dew_point($tf, $hsh{'Humidity_Outside'}); + $tmp = unpack("C", substr $blk,14,1); + $h{Wind} = nearest(0.1, mph2mps($tmp)); + $h{Dir} = unpack("s", substr $blk,16,2)+0; - # $hsh{'UV'} = unpack("C", substr $blk,43,1); - # $hsh{'Solar'} = unpack("s", substr $blk,44,2); # watt/m**2 + my $wind = {w => $h{Wind}, d => $h{Dir}}; + $wind = 0 if $wind == 255; + push @{$ld->{wind_min}}, $wind; - $hsh{'Rain_Rate'} = (unpack("s", substr $blk,41,2) / 100) * 25.4; # Inches per hr converted to mm - $hsh{'Rain_Storm'} = (unpack("s", substr $blk,46,2) / 100) * 25.4; # Inches per storm - #$hsh{'Storm_Date'} = unpack("s", substr $blk,48,2); # Need to parse data (not sure what this is) - $hsh{'Rain_Day'} = (unpack("s", substr $blk,50,2)/100) * 25.4; - $hsh{'Rain_Month'} = (unpack("s", substr $blk,52,2)/100) * 25.4; - $hsh{'Rain_Year'} = (unpack("s", substr $blk,54,2)/100) * 25.4; + $tmp = int(unpack("C", substr $blk,33,1)+0); + if ($tmp > 100) { + dbg "LOOP Outside Humidity out of range ($tmp), record ignored"; + return; + } + $h{Humidity_Out} = $tmp; + $tmp = int(unpack("C", substr $blk,11,1)+0); + if ($tmp > 100) { + dbg "LOOP Inside Humidity out of range ($tmp), record ignored"; + return; + } + $h{Humidity_In} = $tmp; + - $hsh{'ET_Day'} = unpack("s", substr $blk,56,2)/1000; - $hsh{'ET_Month'} = unpack("s", substr $blk,58,2)/100; - $hsh{'ET_Year'} = unpack("s", substr $blk,60,2)/100; + $tmp = unpack("C", substr $blk,43,1)+0; + $h{UV} = $tmp unless $tmp >= 255; + $tmp = unpack("s", substr $blk,44,2)+0; # watt/m**2 + $h{Solar} = $tmp unless $tmp >= 32767; + + # $h{Rain_Rate} = nearest(0.1,unpack("s", substr $blk,41,2) * $rain_mult); + $rain = $h{Rain_Day} = nearest(0.1, unpack("s", substr $blk,50,2) * $rain_mult); + my $delta_rain = $h{Rain} = nearest(0.1, ($rain >= $ld->{last_rain} ? $rain - $ld->{last_rain} : $rain)) if $loop_count; + $ld->{last_rain} = $rain; + + # what sort of packet is it? + my $sort = unpack("C", substr $blk,4,1); + if ($sort) { + + # Newer LOOP2 packet + $tmp = unpack("C", substr $blk,18,2); + # $h{Wind_Avg_10} = nearest(0.1,mph2mps($tmp/10)); + $tmp = unpack("C", substr $blk,20,2); + # $h{Wind_Avg_2} = nearest(0.1,mph2mps($tmp/10)); + $tmp = unpack("C", substr $blk,22,2); + # $h{Wind_Gust_10} = nearest(0.1,mph2mps($tmp/10)); + + # $h{Dir_Avg_10} = unpack("C", substr $blk,24,2)+0; + $tmp = unpack("C", substr $blk,30,2); + $h{Dew_Point} = nearest(0.1, f2c($tmp)); + + } else { + + # Older LOOP packet + $tmp = unpack("C", substr $blk,15,1); + # $h{Wind_Avg_10} = nearest(0.1,mph2mps($tmp)); + $h{Dew_Point} = nearest(0.1, dew_point($h{Temp_Out}, $h{Humidity_Out})); + $h{Rain_Month} = nearest(0.1, unpack("s", substr $blk,52,2) * $rain_mult); + $h{Rain_Year} = nearest(0.1, unpack("s", substr $blk,54,2) * $rain_mult); + } - #$hsh{'Alarms_Inside'} = unpack("b8", substr $blk,70,1); - #$hsh{'Alarms_Rain'} = unpack("b8", substr $blk,70,1); - #$hsh{'Alarms_Outside'} = unpack("b8", substr $blk,70,1); + my $ts = time; + my $s; + my $dayno = int($ts/86400); + my $writeld; + my $cycledata; + + if ($dayno > $ld->{last_day}) { + $ld->{Temp_Out_Max} = $ld->{Temp_Out_Min} = $ld->{Wind_Max} = $temp; + $ld->{Temp_Out_Max_T} = $ld->{Temp_Out_Min_T} = $ld->{Wind_Max_T} = clocktime($ts, 0); + $ld->{last_day} = $dayno; + ++$writeld; + ++$cycledata; + } + if ($temp > $ld->{Temp_Out_Max}) { + $h{Temp_Out_Max} = $ld->{Temp_Out_Max} = $temp; + $h{Temp_Out_Max_T} = $ld->{Temp_Out_Max_T} = clocktime($ts, 0); + ++$writeld; + } + if ($temp < $ld->{Temp_Out_Min}) { + $h{Temp_Out_Min} = $ld->{Temp_Out_Min} = $temp; + $h{Temp_Out_Min_T} = $ld->{Temp_Out_Min_T} = clocktime($ts, 0); + ++$writeld; + } - $hsh{'Batt_Transmitter'} = unpack("C", substr $blk,86,1); # * 0.005859375 - $hsh{'Batt_Console'} = unpack("s", substr $blk,87,2) * 0.005859375; + if ($wind->{w} > $ld->{Wind_Max}) { + $h{Wind_Max} = $ld->{Wind_Max} = $wind->{w}; + $h{Wind_Max_T} = $ld->{Wind_Max_T} = clocktime($ts, 0); + ++$writeld; + } - $hsh{'Forecast_Icon'} = unpack("C", substr $blk,89,1); - $hsh{'Forecast_Rule'} = unpack("C", substr $blk,90,1); + if ($ts >= $ld->{last_hour} + 1800) { + $h{Pressure_Trend} = unpack("C", substr $blk,3,1); + $h{Pressure_Trend_txt} = $bar_trend{$h{Pressure_Trend}}; + $h{Batt_TX_OK} = (unpack("C", substr $blk,86,1)+0) ^ 1; + $h{Batt_Console} = nearest(0.01, unpack("s", substr $blk,87,2) * 0.005859375); + $h{Forecast_Icon} = unpack("C", substr $blk,89,1); + $h{Forecast_Rule} = unpack("C", substr $blk,90,1); + $h{Sunrise} = sprintf( "%04d", unpack("S", substr $blk,91,2) ); + $h{Sunrise} =~ s/(\d{2})(\d{2})/$1:$2/; + $h{Sunset} = sprintf( "%04d", unpack("S", substr $blk,93,2) ); + $h{Sunset} =~ s/(\d{2})(\d{2})/$1:$2/; + + if ($loop_count) { # i.e not the first + my $a = wind_average(scalar @{$ld->{wind_hour}} ? @{$ld->{wind_hour}} : {w => $h{Wind}, d => $h{Dir}}); + + $h{Wind_1h} = nearest(0.1, $a->{w}); + $h{Dir_1h} = nearest(0.1, $a->{d}); + + $a = wind_average(@{$ld->{wind_min}}); + $h{Wind_1m} = nearest(0.1, $a->{w}); + $h{Dir_1m} = nearest(1, $a->{d}); + + ($h{Rain_1m}, $h{Rain_1h}, $h{Rain_24h}) = calc_rain($rain); + + } + $ld->{last_rain_min} = $ld->{last_rain_hour} = $rain; + $h{Temp_Out_Max} = $ld->{Temp_Out_Max}; + $h{Temp_Out_Max_T} = $ld->{Temp_Out_Max_T}; + $h{Temp_Out_Min} = $ld->{Temp_Out_Min}; + $h{Temp_Out_Min_T} = $ld->{Temp_Out_Min_T}; + $h{Wind_Max} = $ld->{Wind_Max}; + $h{Wind_Max_T} = $ld->{Wind_Max_T}; + + $last_hour_h = {%h}; + $s = genstr($ts, 'h', \%h); + $ld->{lasthour_h} = $s; + + $ld->{last_hour} = int($ts/1800)*1800; + $ld->{last_min} = int($ts/60)*60; + @{$ld->{wind_hour}} = (); + @{$ld->{wind_min}} = (); + + if ($s) { + output_str($s, 1); + push @last5daysh, $s; + shift @last5daysh if @last5daysh > 5*24; + } + ++$writeld; + + } elsif ($ts >= $ld->{last_min} + 60) { + my $a = wind_average(@{$ld->{wind_min}}); + my %save; + + push @{$ld->{wind_hour}}, $a; + + if ($loop_count) { # i.e not the first + my $rm; + + $h{Wind_1m} = nearest(0.1, $a->{w}); + $h{Dir_1m} = nearest(1, $a->{d}); + ($h{Rain_1m}, $h{Rain_1h}, $h{Rain_24h}) = calc_rain($rain); + } + $ld->{last_rain_min} = $rain; + $h{Temp_Out_Max} = $ld->{Temp_Out_Max}; + $h{Temp_Out_Max_T} = $ld->{Temp_Out_Max_T}; + $h{Temp_Out_Min} = $ld->{Temp_Out_Min}; + $h{Temp_Out_Min_T} = $ld->{Temp_Out_Min_T}; + $h{Wind_Max} = $ld->{Wind_Max}; + $h{Wind_Max_T} = $ld->{Wind_Max_T}; + + $last_min_h = {%h}; + $s = genstr($ts, 'm', \%h); + $ld->{lastmin_h} = $s; + + $ld->{last_min} = int($ts/60)*60; + @{$ld->{wind_min}} = (); + + output_str($s, 1) if $s; + ++$writeld; + + } else { + my $o = gen_hash_diff($ld->{last_h}, \%h); + if ($o) { + $o->{Dir} ||= $h{Dir}; + $o->{Wind} ||= $h{Wind}; + $o->{Dir} += 0; + $o->{Wind} += 0; + $s = genstr($ts, 'r', $o); + push @last10minsr, $s; + shift @last10minsr while @last10minsr > ($windmins * $updatepermin); + } + else { + dbg "loop rec not changed" if isdbg 'chan'; + } + output_str($s, 0) if $s; + } + $ld->{last_h} = \%h; + write_ld() if $writeld; + cycle_loop_data_files() if $cycledata; + ++$loop_count; + } else { + dbg "CRC check failed for LOOP data!"; + } + return; +} - $hsh{'Sunrise'} = sprintf( "%04d", unpack("S", substr $blk,91,2) ); - $hsh{'Sunrise'} =~ s/(\d{2})(\d{2})/$1:$2/; - $hsh{'Sunset'} = sprintf( "%04d", unpack("S", substr $blk,93,2) ); - $hsh{'Sunset'} =~ s/(\d{2})(\d{2})/$1:$2/; +sub genstr +{ + my $ts = shift; + my $let = shift; + my $h = shift; + + my $j = $json->encode($h); + my $tm = clocktime($ts, 1); + return qq|{"tm":"$tm","t":$ts,"$let":$j}|; +} - #my $nl = ord substr $blk,95,1; - #my $cr = ord substr $blk,96,1; +sub clocktime +{ + my $ts = shift; + my $secsreq = shift; + my ($sec,$min,$hr) = (gmtime $ts)[0,1,2]; + my $s; + if ($secsreq) { + $s = sprintf "%02d:%02d:%02d", $hr, $min, $sec; + } else { + $s = sprintf "%02d:%02d", $hr, $min; + } + return $s; +} - my $crc = unpack "%n", substr($blk,97,2); - my $crc_calc = CRC_CCITT($blk); +sub output_str +{ + my $s = shift; + my $logit = shift; + + dbg $s; +# say $s; + $dlog->writenow($s) if $logit; + foreach my $ws (keys $WS) { + my $tx = $WS->{$ws}; + if ($tx) { + $tx->send($s); + } else { + delete $WS->{$tx}; + } + } +} - if ($crc_calc==0) { - say "inside: $hsh{Air_Temp_Inside_c} degC $hsh{Humidity_Inside}\% outside: $hsh{Air_Temp_Outside_c} degC $hsh{Humidity_Outside}\% wind: $hsh{Wind_Speed_mph} $hsh{Wind_Dir} deg $hsh{Barometric_Press_mb} mB"; - - } else { - print "CRC check failed for LOOP data!\n"; - return 1; +sub gen_hash_diff +{ + my $last = shift; + my $now = shift; + my %o; + my $count; + + while (my ($k, $v) = each %$now) { + if (!exists $last->{$k} || $last->{$k} ne $now->{$k}) { + $o{$k} = $v; + ++$count; + } } - #delete @hsh{'crc', 'crc_calc', 'next_rec'}; - #delete($hsh{crc})||die"cant delete crc"; - #delete($hsh{crc_calc})||die"cant delete crc_calc"; - #delete($hsh{next_rec})||die"cant delete next_rec"; + return $count ? \%o : undef; } sub dew_point @@ -222,9 +622,16 @@ sub dew_point # Accurate to 1 degree C for humidities > 50 % # http://en.wikipedia.org/wiki/Dew_point - my $dew_point = $temp - ( (100 - $rh)/5 ); + my $dewpoint = $temp - ((100 - $rh) / 5); - return $dew_point; + # this is the more complete one (which doesn't work) + #my $a = 6.1121; + #my $b = 18.678; + #my $c = 257.14; + #my $ytrh = log(($rh/100) + ($b * $temp) / ($c + $temp)); + #my $dewpoint = ($c * $ytrh) / ($b - $ytrh); + + return $dewpoint; } sub CRC_CCITT @@ -250,3 +657,144 @@ sub CRC_CCITT return $crc; } +sub f2c +{ + return ($_[0] - 32) * 5/9; +} + +sub mph2mps +{ + return $_[0] * 0.44704; +} + +sub in2mb +{ + return $_[0] * 33.8637526; +} + +sub wind_average +{ + my ($sindir, $cosdir, $wind); + my $count; + + foreach my $r (@_) { + $wind += $r->{w}; + $sindir += sin(d2r($r->{d})) * $r->{w}; + $cosdir += cos(d2r($r->{d})) * $r->{w}; + ++$count; + } + + my $avhdg = r2d(atan2($sindir, $cosdir)); + $avhdg += 360 if $avhdg < 0; + return {w => nearest(0.1,$wind / $count), d => nearest(0.1,$avhdg)}; +} + +# radians to degrees +sub r2d +{ + my $n = shift; + return ($n / pi) * 180; +} + +# degrees to radians +sub d2r +{ + my $n = shift; + return ($n / 180) * pi; +} + +sub calc_rain +{ + my $rain = shift; + + $ld->{rain24} ||= []; + + my $Rain_1h = nearest(0.1, $rain >= $ld->{last_rain_hour} ? $rain - $ld->{last_rain_hour} : $rain); # this is the rate for this hour, so far + my $rm = nearest(0.1, $rain >= $ld->{last_rain_min} ? $rain - $ld->{last_rain_min} : $rain); + my $Rain_1m = nearest(0.1, $rm); + push @{$ld->{rain24}}, $Rain_1m; + $ld->{rain_24} += $rm; + while (@{$ld->{rain24}} > 24*60) { + $ld->{rain_24} -= shift @{$ld->{rain24}}; + } + my $Rain_24h = nearest(0.1, $ld->{rain_24}); + return ($Rain_1m, $Rain_1h, $Rain_24h); +} + +sub read_ld +{ + unless ($dataf) { + $dataf = IO::File->new("+>> $datafn") or die "cannot open $datafn $!"; + $dataf->autoflush(1); + } + + seek $dataf, 0, 0; + my $s = <$dataf>; + chomp $s; + dbg "read loop data: $s" if isdbg 'json'; + $ld = $json->decode($s) if length $s; + + # sort out rain stats + my $c; + if ($ld->{rain24} && ($c = @{$ld->{rain24}}) < 24*60) { + my $diff = 24*60 - $c; + unshift @{$ld->{rain24}}, 0 for 0 .. $diff; + } + my $rain; + + if ($ld->{rain24}) { + $rain += $_ for @{$ld->{rain24}}; + } + + $ld->{rain_24} = nearest(0.1, $rain); + delete $ld->{hour}; + delete $ld->{min}; +} + +sub write_ld +{ + unless ($dataf) { + $dataf = IO::File->new("+>> $datafn") or die "cannot open $datafn $!"; + $dataf->autoflush(1); + } + + seek $dataf, 0, 0; + truncate $dataf, 0; + $ld->{ts} = time; + my $s = $json->encode($ld); + dbg "write loop data: $s" if isdbg 'json'; + print $dataf "$s\n"; +} + +sub cycle_loop_data_files +{ + $dataf->close if $dataf; + undef $dataf; + + rename "$datafn.oooo", "$datafn.ooooo"; + rename "$datafn.ooo", "$datafn.oooo"; + rename "$datafn.oo", "$datafn.ooo"; + rename "$datafn.o", "$datafn.oo"; + copy $datafn, "$datafn.o"; +} + +sub grab_history +{ + my $lg = shift; + my $let = shift; + my $start = shift || time - 86400; + my $dayno = shift; + my @out; + + if ($lg->open($dayno, 'r+')) { + while (my $l = $lg->read) { + next unless $l =~ /,"$let":/; + my ($t) = $l =~ /"t":(\d+)/; + if ($t && $t >= $start) { + push @out, $l; + } + } + $lg->close; + } + return @out; +}