X-Git-Url: http://gb7djk.dxcluster.net/gitweb/gitweb.cgi?a=blobdiff_plain;f=Loop.pm;h=6590e504395983f7381637872127f564e7e47a02;hb=6e03f8c08e990182830f8a8d9b240445af94a55a;hp=e76f1ff33b3b2ce597150e087c00fa4abb660638;hpb=b4db08ed5cfe84618f1820fdc49b716ccaca61ec;p=dweather.git

diff --git a/Loop.pm b/Loop.pm
index e76f1ff..6590e50 100755
--- a/Loop.pm
+++ b/Loop.pm
@@ -1,22 +1,53 @@
 #!/usr/bin/perl
-
 package Loop;
 
 use strict;
 
 use v5.10.1;
 
+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 $devname = "/dev/davis";
+my $datafn = ".loop_data";
+my $dataf;
+
+our $poll_interval = 2.5;
+our $rain_mult = 0.2;    			# 0.1 or 0.2 mm or 0.01 inches
+my $tid;
+my $rid;
+our $did;
+my $nlcount;
+my $state = "ready";
+my $buf;
+my $ser;							# the serial port Mojo::IOLoop::Stream
+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,
@@ -63,170 +94,141 @@ $bar_trend{0} = "Steady";
 $bar_trend{20} = "Rising Slowly";
 $bar_trend{60} = "Rising Rapidly";
 
-our $ending = 0;
+sub init
 
-$SIG{TERM} = $SIG{INT} = sub {++$ending; Mojo::IOLoop->stop;};
-$SIG{HUP} = 'IGNORE';
-
-sub new
 {
-	my $pkg = shift;
-	my $class = ref $pkg || $pkg;
-	my $self = bless {}, $class;
-	$self->{poll_interval} ||= 2.5;
-	$self->{rain_mult} ||= 0.2;    			# 0.1 or 0.2 mm or 0.01 inches
-	$self->{devname} ||= "/dev/davis";
-	$self->{datafn} ||= ".loop_data";
-	$self->{state} ||= "ready";
-
-	open $self->{dataf}, "+>>", $self->{dataf} or die "cannot open $self->{dataf} $!";
-	$self->{dataf}->autoflush(1);
-	$self->read_ld;
-
-	dbg "last_min: " . scalar gmtime($self->{ld}->{last_min});
-	dbg "last_hour: " . scalar gmtime($self->{ld}->{last_hour});
-
-	return $self;
+	our $dlog = SMGLog->new("day");
+	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);
 }
 
-sub start
-{
-	my $self = shift;
 	
-	$self->{did} = Mojo::IOLoop->recurring(1 => sub {$main::dlog->flushall});
-	$self->do_reopen($self->{devname});
-}
-
-sub stop
+sub loop
 {
-	my $self = shift;
+	dbg "last_min: " . scalar gmtime($ld->{last_min});
+	dbg "last_hour: " . scalar gmtime($ld->{last_hour});
 	
-	$self->write_ld;
-
-	$self->{ser}->close if $self->{ser};
-	close $self->{dataf} if $self->{dataf};
-	delete $self->{dataf};
-}
-
-sub DESTROY
-{
-	my $self = shift;
-	$self->stop if $self->{dataf};
+	$did = Mojo::IOLoop->recurring(1 => sub {$dlog->flushall});
+	
+	do_reopen($devname);
 }
 
 sub on_read
 {
-	my ($self, $d) = @_;
-	$self->{buf} .= $d;
+	my ($ser, $d) = @_;
+	$buf .= $d;
 	$d =~ s/([\%\x00-\x1f\x7f-\xff])/sprintf("%%%02X", ord($1))/eg; 
-	dbg "read added '$d' buf lth=" . length $self->{buf} if isdbg 'raw';
-	if ($self->{state} eq 'waitnl' && $self->{buf} =~ /[\cJ\cM]+/) {
+	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($self->{tid}) if $self->{tid};
-		delete $self->{tid};
-		delete $self->{buf};
-		$self->{nlcount} = 0;
-		$self->{ser}->write("LPS 1 1\n");
-		$self->chgstate("waitloop");
-	} elsif ($self->{state} eq "waitloop") {
-		if ($self->{buf} =~ /\x06/) {
+		Mojo::IOLoop->remove($tid) if $tid;
+		undef $tid;
+		undef $buf;
+		$nlcount = 0;
+		$ser->write("LPS 1 1\n");
+		chgstate("waitloop");
+	} elsif ($state eq "waitloop") {
+		if ($buf =~ /\x06/) {
 			dbg "Got ACK 0x06" if isdbg 'state';
-			$self->chgstate('waitlooprec');
-			delete $self->{buf};
+			chgstate('waitlooprec');
+			undef $buf;
 		}
-	} elsif ($self->{state} eq 'waitlooprec') {
-		if (length $self->{buf} >= 99) {
+	} elsif ($state eq 'waitlooprec') {
+		if (length $buf >= 99) {
 			dbg "got loop record" if isdbg 'chan';
-			$self->chgstate('');
-			$self->process;
-			delete $self->{buf};
+			chgstate('');
+			process($buf);
+			undef $buf;
 		}
 	}
 }
 
 sub start_loop
 {
-	my $self = shift;
-	
-	$self->{nlcount} = 1;
-	dbg "start_loop writing $self->{nlcount} \\n" if isdbg 'state';
-	$self->{ser}->write("\n");
-	Mojo::IOLoop->remove($self->{tid}) if $self->{tid};
-	delete $self->{tid};
-	$self->{tid} = Mojo::IOLoop->recurring(0.6 => sub {
-									   if (++$self->{nlcount} > 10) {
+	$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) {
 										   dbg "\\n count > 10, closing connection" if isdbg 'chan';
-										   do_reopen($self->{devname});
+										   do_reopen($devname);
 										   return;
 									   }
-									   dbg "writing $self->{nlcount} \\n" if isdbg 'state'; 
-									   $self->{ser}->write("\n");
+									   dbg "writing $nlcount \\n" if isdbg 'state'; 
+									   $ser->write("\n");
 								   });
-	$self->chgstate("waitnl");
+	chgstate("waitnl");
 }
 
 sub chgstate
 {
-	my $self = shift;
-	dbg "state '$self->{state}' -> '$_[0]'" if isdbg 'state';
-	$self->{state} = $_[0];
+	dbg "state '$state' -> '$_[0]'" if isdbg 'state';
+	$state = $_[0];
 }
 
 sub do_reopen
 {
-	my $self = shift;
 	my $name = shift;
 	dbg "do reopen on '$name' ending $ending";
 	unless ($ending) {
-		$self->{ser} = do_open($name);
-		$self->start_loop;
-		$self->chgstate('');
-		$self->{nlcount} = 0;
-		Mojo::IOLoop->next_tick(sub {$self->do_reopen});
+		$ser = do_open($name);
+		start_loop();
+		chgstate('');
+		$nlcount = 0;
+		Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
 	}
 }
 
 sub do_open
 {
-	my $self = shift;
 	my $name = shift;
 
-	$self->{ser}->close if $self->{ser};
-	delete $self->{ser};
+	$ser->close if $ser;
+	undef $ser;
 
 	my $ob = Serial->new($name, 19200) || die "$name $!\n";
 	dbg "streaming $name fileno(" . fileno($ob) . ")" if isdbg 'chan';
 	
-	my $self->{ser} = Mojo::IOLoop::Stream->new($ob);
-	$self->{ser}->on(error=>sub {dbg "serial $_[1]"; do_reopen($name) unless $ending});
-	$self->{ser}->on(close=>sub {dbg "serial closing"; do_reopen($name) unless $ending});
-	$self->{ser}->on(timeout=>sub {dbg "serial timeout";});
-	$self->{ser}->on(read=>sub {on_read(@_)});
-	$self->{ser}->start;
-
-	Mojo::IOLoop->remove($self->{tid}) if $self->{tid};
-	delete $self->{tid};
-	Mojo::IOLoop->remove($self->{rid}) if $self->{rid};
-	delete $self->{rid};
-	$self->{rid} = Mojo::IOLoop->recurring($self->{poll_interval} => sub {
-									   start_loop() if !$self->{state};
+	my $ser = Mojo::IOLoop::Stream->new($ob);
+	$ser->on(error=>sub {dbg "serial $_[1]"; do_reopen($name) unless $ending});
+	$ser->on(close=>sub {dbg "serial closing"; do_reopen($name) unless $ending});
+	$ser->on(timeout=>sub {dbg "serial timeout";});
+	$ser->on(read=>sub {on_read(@_)});
+	$ser->start;
+
+	Mojo::IOLoop->remove($tid) if $tid;
+	undef $tid;
+	Mojo::IOLoop->remove($rid) if $rid;
+	undef $rid;
+	$rid = Mojo::IOLoop->recurring($poll_interval => sub {
+									   start_loop() if !$state;
 								   });
-	$self->chgstate('');
-	$self->{nlcount} = 0;
+	chgstate('');
+	$nlcount = 0;
 	
-	return $self->{ser};
+	return $ser;
 }
 
+my @min;
+my @hour;
+
 sub process
 {
-	my $self = shift;
-	my $blk = $self->{buf};
+	my $blk = shift;
 	my $loo =  substr $blk,0,3;
 	unless ( $loo eq 'LOO') {
 		dbg "Block invalid loo -> $loo" if isdbg 'chan'; return;
 	}
 
 	my $tmp;
+	my $temp;
 	my $rain;
 	my %h;
 
@@ -241,28 +243,44 @@ sub process
 		$tmp = unpack("s", substr $blk,9,2) / 10;
 		$h{Temp_In} = nearest(0.1, f2c($tmp));
 
-		$tmp  = unpack("s", substr $blk,12,2) / 10;
-		$h{Temp_Out}  = 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;
+		}
 
 		$tmp = unpack("C", substr $blk,14,1);
 		$h{Wind} = nearest(0.1, mph2mps($tmp));
 		$h{Dir}     = unpack("s", substr $blk,16,2)+0;
 
 		my $wind = {w => $h{Wind}, d => $h{Dir}};
-		push @{$self->{ld}->{wind_min}}, $wind;
+		$wind = 0 if $wind == 255;
+		push @{$ld->{wind_min}}, $wind;
 
-		$h{Humidity_Out} = unpack("C", substr $blk,33,1)+0;
-		$h{Humidity_In}  = unpack("C", substr $blk,11,1)+0;
+		$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;
+		
 
 		$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) * $self->{rain_mult});
-		$rain = $h{Rain_Day}   = nearest(0.1, unpack("s", substr $blk,50,2) * $self->{rain_mult});
-		my $delta_rain = $h{Rain} = nearest(0.1, ($rain >= $self->{ld}->{last_rain} ? $rain - $self->{ld}->{last_rain} : $rain)) if $self->{loop_count};
-		$self->{ld}->{last_rain} = $rain;
+		#	$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);
@@ -286,13 +304,32 @@ sub process
 			$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) * $self->{rain_mult});
-			$h{Rain_Year}  = nearest(0.1, unpack("s", substr $blk,54,2) * $self->{rain_mult});
+			$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);
 		}
 
 		my $ts = time;
 		my $s;
-		if ($ts >= $self->{ld}->{last_hour} + 3600) {
+		my $dayno = int($ts/86400);
+		if ($dayno > $ld->{last_day}) {
+			$ld->{Temp_Out_Max} = $ld->{Temp_Out_Min} = $temp;
+			$ld->{Temp_Out_Max_T} = $ld->{Temp_Out_Min_T} = clocktime($ts, 0);
+			$ld->{last_day} = $dayno;
+			write_ld();
+			cycle_loop_data_files();
+		}
+		if ($temp > $ld->{Temp_Out_Max}) {
+			$ld->{Temp_Out_Max} = $temp;
+			$ld->{Temp_Out_Max_T} = clocktime($ts, 0);
+			write_ld();
+		}
+		if ($temp < $ld->{Temp_Out_Min}) {
+			$ld->{Temp_Out_Min} = $temp;
+			$ld->{Temp_Out_Min_T} = clocktime($ts, 0);
+			write_ld();
+		}
+
+		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;
@@ -303,64 +340,90 @@ sub process
 			$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/;
+			$h{Temp_Out_Max} = $ld->{Temp_Out_Max};
+			$h{Temp_Out_Min} = $ld->{Temp_Out_Min};
+			$h{Temp_Out_Max_T} = $ld->{Temp_Out_Max_T};
+			$h{Temp_Out_Min_T} = $ld->{Temp_Out_Min_T};
+			
 
-			if ($self->{loop_count}) {	# i.e not the first
-				my $a = wind_average(scalar @{$self->{ld}->{wind_hour}} ? @{$self->{ld}->{wind_hour}} : {w => $h{Wind}, d => $h{Dir}});
+			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(@{$self->{ld}->{wind_min}});
+				$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}) = $self->calc_rain($rain);
+				($h{Rain_1m}, $h{Rain_1h}, $h{Rain_24h}) = calc_rain($rain);
 			}
-			$self->{ld}->{last_rain_min} = $self->{ld}->{last_rain_hour} = $rain;
+			$ld->{last_rain_min} = $ld->{last_rain_hour} = $rain;
 
+			$last_hour_h = {%h};
 			$s = genstr($ts, 'h', \%h);
+			$ld->{lasthour_h} = $s;
 			
-			$self->{ld}->{last_hour} = int($ts/3600)*3600;
-			$self->{ld}->{last_min} = int($ts/60)*60;
-			@{$self->{ld}->{wind_hour}} = ();
-			@{$self->{ld}->{wind_min}} = ();
-
+			$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;
+			}
 			write_ld();
 			
-		} elsif ($ts >= $self->{ld}->{last_min} + 60) {
-			my $a = wind_average(@{$self->{ld}->{wind_min}});
+		} elsif ($ts >= $ld->{last_min} + 60) {
+			my $a = wind_average(@{$ld->{wind_min}});
 			my %save;
 
-			push @{$self->{ld}->{wind_hour}}, $a;
+			push @{$ld->{wind_hour}}, $a;
 
-			if ($self->{loop_count}) {	# i.e not the first
+			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}) = $self->calc_rain($rain);
+				($h{Rain_1m}, $h{Rain_1h}, $h{Rain_24h}) = calc_rain($rain);
 			}
-			$self->{ld}->{last_rain_min} = $rain;
+			$ld->{last_rain_min} = $rain;
+
+			$h{Temp_Out_Max} = $ld->{Temp_Out_Max};
+			$h{Temp_Out_Min} = $ld->{Temp_Out_Min};
+			$h{Temp_Out_Max_T} = $ld->{Temp_Out_Max_T};
+			$h{Temp_Out_Min_T} = $ld->{Temp_Out_Min_T};
 
+			$last_min_h = {%h};
 			$s = genstr($ts, 'm', \%h);
+			$ld->{lastmin_h} = $s;
 			
-			$self->{ld}->{last_min} = int($ts/60)*60;
-			@{$self->{ld}->{wind_min}} = ();
+			$ld->{last_min} = int($ts/60)*60;
+			@{$ld->{wind_min}} = ();
 			
+			output_str($s, 1) if $s;
 			write_ld();
 
 		} else {
-			my $o = gen_hash_diff($self->{ld}->{last_h}, \%h);
+			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;
 		}
-		output_str($s) if $s;
-		$self->{ld}->{last_h} = \%h;
-		++$self->{loop_count};
+		$ld->{last_h} = \%h;
+		++$loop_count;
 	} else {
 		dbg "CRC check failed for LOOP data!";
 	}
@@ -374,18 +437,40 @@ sub genstr
 	my $h = shift;
 	
 	my $j =  $json->encode($h);
-	my ($sec,$min,$hr) = (gmtime $ts)[0,1,2];
-	my $tm = sprintf "%02d:%02d:%02d", $hr, $min, $sec;
-	
+	my $tm = clocktime($ts, 1);
 	return qq|{"tm":"$tm","t":$ts,"$let":$j}|;
 }
 
+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;
+}
+
 sub output_str
 {
 	my $s = shift;
+	my $logit = shift;
+	
 	dbg $s;
 #	say $s;
-	$main::dlog->writenow($s);
+	$dlog->writenow($s) if $logit;
+	foreach my $ws (keys $WS) {
+		my $tx = $WS->{$ws};
+		if ($tx) {
+			$tx->send($s);
+		} else {
+			delete $WS->{$tx};
+		}
+	}
 }
 
 sub gen_hash_diff
@@ -396,7 +481,7 @@ sub gen_hash_diff
 	my $count;
 
 	while (my ($k, $v) = each %$now) {
-		if ($last->{$k} ne $now->{$k}) {
+		if (!exists $last->{$k} || $last->{$k} ne $now->{$k}) {
 			$o{$k} = $v;
 			++$count;
 		}
@@ -496,60 +581,98 @@ sub d2r
 
 sub calc_rain
 {
-	my $self = shift;
 	my $rain = shift;
 	
-	$self->{ld}->{rain24} ||= [];
+	$ld->{rain24} ||= [];
 	
-	my $Rain_1h = nearest(0.1, $rain >= $self->{ld}->{last_rain_hour} ? $rain - $self->{ld}->{last_rain_hour} : $rain); # this is the rate for this hour, so far
-	my $rm = $rain >= $self->{ld}->{last_rain_min} ? $rain - $self->{ld}->{last_rain_min} : $rain;
+	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 @{$self->{ld}->{rain24}}, $Rain_1m;
-	$self->{ld}->{rain_24} += $rm;
-	while (@{$self->{ld}->{rain24}} > 24*60) {
-		$self->{ld}->{rain_24} -= shift @{$self->{ld}->{rain24}};
+	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, $self->{ld}->{rain_24});
+	my $Rain_24h = nearest(0.1, $ld->{rain_24});
 	return ($Rain_1m, $Rain_1h, $Rain_24h);
 }
 
 sub read_ld
 {
-	my $self = shift;
-	
-	return unless $self->{dataf};
+	unless ($dataf) {
+		$dataf = IO::File->new("+>> $datafn") or die "cannot open $datafn $!";
+		$dataf->autoflush(1);
+	}
 
-	seek $self->{dataf}, 0, 0;
-	my $s = $self->{dataf};
+	seek $dataf, 0, 0;
+	my $s = <$dataf>;
 	chomp $s;
 	dbg "read loop data: $s" if isdbg 'json';
-	$self->{ld} = $json->decode($s) if length $s;
+	$ld = $json->decode($s) if length $s;
 	
 	# sort out rain stats
 	my $c;
-	if (($c = @{$self->{ld}->{rain24}}) < 24*60) {
+	if ($ld->{rain24} && ($c = @{$ld->{rain24}}) < 24*60) {
 		my $diff = 24*60 - $c;
-		unshift @{$self->{ld}->{rain24}}, 0 for 0 .. $diff;  
+		unshift @{$ld->{rain24}}, 0 for 0 .. $diff;  
 	}
 	my $rain;
-	$rain += $_ for @{$self->{ld}->{rain24}};
-	$self->{ld}->{rain_24} = nearest(0.1, $rain);
-	delete $self->{ld}->{hour};
-	delete $self->{ld}->{min};
+	
+	if ($ld->{rain24}) {
+		$rain += $_ for @{$ld->{rain24}};
+	}
+	
+	$ld->{rain_24} = nearest(0.1, $rain);
+	delete $ld->{hour};
+	delete $ld->{min};
 }
 
 sub write_ld
 {
-	my $self = shift;
+	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;
 	
-	return unless $self->{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;
 	
-	seek $self->{dataf}, 0, 0;
-	truncate $self->{dataf}, 0;
-	$self->{ld}->{ts} = time;
-	my $s = $json->encode($self->{ld});
-	dbg "write loop data: $s" if isdbg 'json';
-	$self->{dataf}->print("$s\n");
+	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;
 }
 
 1;