#!/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,
$bar_trend{20} = "Rising Slowly";
$bar_trend{60} = "Rising Rapidly";
-our $ending = 0;
-
-$SIG{TERM} = $SIG{INT} = sub {++$ending; Mojo::IOLoop->stop;};
-$SIG{HUP} = 'IGNORE';
+sub init
-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;
-}
-
-sub start
-{
- $self->{did} = Mojo::IOLoop->recurring(1 => sub {$dlog->flushall});
- do_reopen($self->{devname});
-}
-
-sub stop
-{
- $self->write_ld;
- close $self->{dataf} if $self->{dataf};
- delete $self->{dataf};
+ 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 DESTROY
+
+sub loop
{
- my $self = shift;
- $self->stop if $self->{dataf};
+ dbg "last_min: " . scalar gmtime($ld->{last_min});
+ dbg "last_hour: " . scalar gmtime($ld->{last_hour});
+
+ $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};
- undef $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);
+ $ser = do_open($name);
start_loop();
- $self->chgstate('');
- $self->{nlcount} = 0;
- Mojo::IOLoop->next_tick(sub {do_reopen {
- } while (_); }) unless Mojo::IOLoop->is_running;
+ 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};
- undef $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};
- undef $self->{tid};
- Mojo::IOLoop->remove($self->{rid}) if $self->{rid};
- undef $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;
$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);
$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;
$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!";
}
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;
- $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
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;
}
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';
$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;
-
- return unless $self->{dataf};
-
- seek $self->{dataf}, 0, 0;
- truncate $self->{dataf}, 0;
- $self->{ld}->{ts} = time;
+ 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 $self->{dataf} "$s\n";
+ 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;
}
1;
projects / dweather.git / blobdiff