#!/usr/bin/perl -w  
# recordData.pl - record accelerometer readings and wireless signal strength
# usage: recordData.pl | tee logFile
use strict;
use Time::HiRes qw( usleep );

$|=1; # non-buffered output

my $hdapsFN = "/sys/devices/platform/hdaps/position"; # hdaps data
my $netwkFN = "/proc/net/wireless";                   # network data
my ($restX, $restY ) = ""; # default position of hdaps sensors
my $SLEEP_INTERVAL = 50000; # microseconds to pause between data reads

# setup the default position of the hdaps sensor values
($restX, $restY ) = readPosition();

while(1)
{
  my ($currX, $currY) = readPosition();
  $currX -= $restX;  # adjust for rest data state
  $currY -= $restY;

  print Time::HiRes::time(), " ", readSignal(), " $currX $currY \n";
  usleep($SLEEP_INTERVAL);
}#end main loop

# begin subroutines

sub readPosition
{
  my ($posX, $posY) = "";
  open(FH," $hdapsFN") or die "can't open hdaps file";
    while(my $hdapsLine = <FH> )
    { 
      $hdapsLine =~ s/(\(|\))//g; # remove parens
      ($posX, $posY) = split ",", $hdapsLine;
    }# while hdaps line read
  close(FH);
  return( $posX, $posY );
}#readPosition

sub readSignal
{ 
  my $sigLev = 0;
  open(FH," $netwkFN") or die "can't open wireless network file";
    while( my $networkLine = <FH> )
    { 
      next unless( /eth/ );
      (undef, undef, undef, $sigLev ) = split " ", $networkLine;
    }# while read
  close(FH);
  return( $sigLev );
}#readSignal

                
...
1199973721.01845 179.  -15 -140 
1199973721.06944 181.  -11 -141 
1199973721.12043 181.  -8 -139 
1199973721.22242 183.  -4 -139 
...

                
#!/usr/bin/perl -w
# detectEnds.pl - find rest/walking/rest section of recordData.pl output
# usage: cat logFile |  detectEnds.pl > endFile
use strict;
my @dataArr = ();
my $maxDeviation = 1;
my $minimumData = 40; # 2 seconds at 20 samples/sec
my $lastMode = "start";

while(my $line = <STDIN> )
{ 
  my( $time, $signal, $x, $y ) = split " ", $line;

  # only process entries where unit is rotated properly
  next if( $y > -100 );

  push @dataArr, $y;  # add to the data sample

  # if at least N seconds or data has been recorded
  next if( @dataArr <= $minimumData );

  # zero deviation is near zero movement (rest), deviation 4 or more is walking
  my $deviation = avgCheck(9) + avgCheck(19) + avgCheck(29) + avgCheck(39);

  if( $deviation == 0 )
  { 
    # first rest, before any other state
    $lastMode = "rest" if( $lastMode eq "start" );

    # terminate if post-walking rest detected
    exit(0) if ( $lastMode eq "walking" );

  }elsif( $deviation >= 4 )
  { 
    # set walking mode on first rest detection
    $lastMode = "walking" if( $lastMode eq "rest" );

  }#check deviation

  shift @dataArr;  # maintain a minimumData size sample
  print $line if( $lastMode eq "rest"  || $lastMode eq "walking" );
}#while line in 

# begin subroutines 

sub avgCheck
{ 
  # build and average of two seconds worth of data, return an integer of it's
  # deviation from the center point
  my $avgIndex = $_[0];
  my $avgArr = 0;
  for my $eachArr ( @dataArr ){ $avgArr += $eachArr };
  $avgArr = $avgArr / ($minimumData+1);

  return(1) if(  abs( $dataArr[$avgIndex] - $avgArr ) > $maxDeviation );
  return(0);
}# avgCheck

perl -e 'while($c<3){`cat logFile$c | perl detectEnds.pl > endFile$c`;$c++}'

                
#!/usr/bin/perl -w 
# findStep.pl - indicate peaks and nadirs (left and right steps) in an endFile
use strict;
die "usage: cat endFile | findStep.pl dataSz lowOrder > steps" unless @ARGV==2;

my $dataSz   = $ARGV[0]; # number of samples to process for a wave
my $lowOrder = $ARGV[1]; # level of modulation that indicates a low order wave
my @lineArr = ();

# read the whole file in to set defaults and compute total data size
while( my $line = <STDIN> )
{
  chomp($line);
  push @lineArr, "default $line -60 -240 ";
}#while stdin

die "specify dataSz at most (totalSampleSize/2)-1" if ( (@lineArr/2)+1 < $dataSz );

my $lineNum = $dataSz; # skip the first N samples (known 'resting' mode)

for( $lineNum = $dataSz; $lineNum < (@lineArr-$dataSz); $lineNum++ )
{
  my ( undef, $time, $signal, $x, $y ) = split " ", $lineArr[$lineNum];

  # require a coffee bender before twitch=step
  next unless ( highOrderWave($lineNum, $y) == 1);

  if( findModulation( "peak", $lineNum, $y ) == (($dataSz*2)+1) )
  {
    $lineArr[$lineNum] =~ s/default/peak   /i;
    $lineArr[$lineNum] = "peak $time $signal $x $y $y -240";
  }elsif( findModulation( "nadir", $lineNum, $y ) == (($dataSz*2)+1) )
  {
    $lineArr[$lineNum] =~ s/default/nadir  /i;
    $lineArr[$lineNum] = "nadir $time $signal $x $y -60 $y";
  }#if peak or nadir detected

}#for each linearr

for my $lineItem( @lineArr ){ print "$lineItem\n" }

                
sub highOrderWave
{   
  my(  $startVal, $currY ) = @_;
  my $avgSize = 0;
  
  # for selected sample size before and after current position, build average
  for( my $pos = ($startVal-$dataSz); $pos <= ($startVal+$dataSz); $pos++ )
  { 
    my ( undef, undef, undef, undef, $checkY ) = split " ", $lineArr[$pos];
    $avgSize += $checkY;
  }#for each position dataSz before and after
  
  $avgSize = $avgSize / (($dataSz*2)+1);
  $avgSize = abs($avgSize - $currY);
  
  return(0) if( $avgSize <  $lowOrder );
  return(1);

}#highOrderWave

                
sub findModulation
{ 
  my( $peakType, $startVal, $currY ) = @_;
  my $totalMatch = 0;

  # for selected sample size before and after current position
  for( my $pos = ($startVal-$dataSz); $pos <= ($startVal+$dataSz); $pos++ )
  { 
    # stop checking if a previous modulation found nearby
    return(0) if( $lineArr[$pos] =~ /$peakType/ );

    my ( undef, undef, undef, undef, $checkY ) = split " ", $lineArr[$pos];

    if( $peakType eq "peak" ){     $totalMatch++ if( $checkY <= $currY ); }
    elsif( $peakType eq "nadir" ){ $totalMatch++ if( $checkY >= $currY ); }

  }#for each position dataSz before and after

  return( $totalMatch );

}#findModulation

                
#!/usr/bin/perl -w
# rowRender.pl - draw alpha blended signal strength circles at each step
use strict;
die "usage: cat steps | rowRender.pl inImg outImg stX stY size" unless @ARGV==5;
my $alpha = 220;      # alpha color blending for signal circles
my @steps = ();       # signal measurements
my $cmd = "convert "; # beginning of ImageMagick command
my ($inFile, $outFile, $startX, $startY, $dotSize) = @ARGV; # input, output files

# pre-compute the number of steps
while(my $line = <STDIN>)
{
  my( undef, undef, $signal, undef, undef) = split " ", $line;
  push @steps, $signal  if( $line =~ /(peak|nadir)/ );
}#while stdin

# assumes consistent width through entire image
my( undef, undef, $width ) = split " ", `identify $inFile`;
$width = substr($width, 0, index($width,"x"));
$width = $width - ($startX * 2);   # right image border compensation

# set stepSize manually for blueprint images with irregular borders, an 'L'
# shaped building for example
my $stepSize = $width / @steps;

for( my $lineNum = 0; $lineNum < @steps; $lineNum++ )
{
  $cmd .= qq{ -fill "rgba(} . computeColor($steps[$lineNum]) . qq{,$alpha)" };
  $cmd .= qq( -draw 'circle $startX,$startY, );
  $cmd .= ($startX + $dotSize) . "," . ($startY + $dotSize) . qq(' \\\n);

  runCommand() if( $lineNum % 50 == 0 );
  $startX += $stepSize;

}#for each step

runCommand();

                
sub computeColor
{ 
  # simplistic computation of custom color range based on signal levels
  my $signal = $_[0];

  my $color = qq(255,140,10); # default orange
  if( $signal >= 197 && $signal < 207  )
  {
    $color = abs( $signal - 207 );
    $color = $color * 8;           # intervals of 10
    $color = $color + 175;         # starting at green 175
    $color = qq(59,$color,10);

  }elsif( $signal >= 189 && $signal < 197 )
  {
    $color = abs( $signal - 197 );
    $color = $color * 18;          # 10 intervals
    $color = $color + 75;          # starting at red 75
    $color = qq($color,234,39);

  }elsif( $signal >= 181 && $signal < 189 )
  {
    $color = abs( $signal - 189 );
    $color = $color * 15;          # 10 intervals
    $color = $color + 124;         # starting at green 124
    $color = qq(255,$color,10);
  }
  return($color);
}#computeColor

sub runCommand
{
  $cmd = `$cmd $inFile $outFile`;
  $inFile = "$outFile"; # use output as input for multi-pass image writing
  $cmd = qq( convert );
}#runCommand

                
cat steps0 |perl rowRender1.pl bluePrint.png out.png 20 44 30
cat steps1 |perl rowRender1.pl out.png out.png       20 74 30
cat steps2 |perl rowRender1.pl out.png out.png       20 99 30
..
cat stepsN |perl rowRender1.pl out.png done.png      X  Y  dotSize

                
convert -transparent "#FFFFFF" bluePrint.png transparent.png
composite -compose over transparent.png done.png finalImg.png