Linux 笔记本基于“敲打”的命令

require 'sys/syscall.ph';  # for subsecond timing

my $option = $ARGV[0] || ""; # simple option handling

# filename for hdaps sensor reads
my $hdapsFN = "/sys/devices/platform/hdaps/position";


my $UPDATE_THRESHOLD =   4;      # threshold of force that indicates a knock
my $INTERVAL_THRESHOLD = 100000; # microseconds of time required between knock
# events
my $SLEEP_INTERVAL =     0.01;   # time to pause between hdaps reads

my $MAX_TIMEOUT_LENGTH = 4;      # maximum length in seconds of knock pattern
# length
my $MAX_KNOCK_DEV =      100000; # maximum acceptable deviation between recorded
# pattern values and knocking values

my $LISTEN_TIMEOUT =     2;      # timeout value in seconds between knock
# events when in listening mode

my @baseKnocks = ();             # contains knock intervals currently entered
my %knockHash = ();              # contains knock patterns, associated commands

my $prevInterval =       0;      # previous interval of time
my $knockCount =         0;      # current number of knocks detected

my $restX = 0; # `resting' positiong of X axis accelerometer
my $restY = 0; # `resting' positiong of Y axis accelerometer
my $currX = 0; # current position of X axis accelerometer
my $currY = 0; # current position of Y axis accelerometer
my $lastX = 0; # most recent position of X axis accelerometer
my $lastY = 0; # most recent position of Y axis accelerometer


my $startTime = 0;  # to manage timeout intervals
my $currTime  = 0;  # to manage timeout intervals
my $timeOut   = 0;  # perpetual loop variable
my $knockAge  = 0;  # count of knocks to cycle time interval

sub checkAccelerometer() {

my $ret;
$ret = readPosition ();
if( $ret ){
print "no accelerometer data available - tis bork ed\n";
exit(1);
}

}#checkAccelerometer

## comments from Jeff Molofee in hdaps-gl.c
#* read_position - read the (x,y) position pair from hdaps.
#*
#* We open and close the file on every invocation, which is lame but due to
#* several features of sysfs files:
#*
#*  (a) Sysfs files are seekable.
#*  (b) Seeking to zero and then rereading does not seem to work.
##
sub readPosition() {

my ($posX, $posY) = "";
my $fd = open(FH," $hdapsFN");

while( <FH> ){
s/\(//g;
s/\)//g;
($posX, $posY) = split ",";

}# while read

close(FH);

return( $posX, $posY );

}#readPosition

sub getEpochMicroSeconds {

my $TIMEVAL_T = "LL";      # LL for microseconds
my $timeVal = pack($TIMEVAL_T, ());

syscall(&SYS_gettimeofday, $timeVal, 0) != -1 or die "micro seconds: $!";
my @vals =  unpack( $TIMEVAL_T, $timeVal );
$timeVal = $vals[0] . $vals[1];
$timeVal = substr( $timeVal, 6);

my $padLen =  10 - length($timeVal);
$timeVal = $timeVal . "0" x $padLen;

return($timeVal);
}#getEpochMicroSeconds


sub getEpochSeconds {
my $TIMEVAL_T = "LL";      # LL for microseconds
my $start = pack($TIMEVAL_T, ());
syscall(&SYS_gettimeofday, $start, 0) != -1 or die "seconds: $!";
return( (unpack($TIMEVAL_T, $start))[0] );
}#getEpochSeconds

sub knockListen() {

my $checkKnock = 0;
($currX, $currY) = readPosition();

$currX -= $restX;  # adjust for rest data state
$currY -= $restY;  # adjust for rest data state


# require a high threshold of acceleration to ignore non-events like
# bashing the enter key or hitting the side with the mouse
if( abs ($currX) > $UPDATE_THRESHOLD) {
$checkKnock = 1;
}

if( abs ($currY) > $UPDATE_THRESHOLD) {
$checkKnock = 1;
}


if( $checkKnock == 1 ){

my $currVal = getEpochMicroSeconds();
my $diffInterval = abs($prevInterval - $currVal);

# hard knock events can create continuous acceleration across a large time
# threshold.  requiring an elapsed time between knock events effectively
# reduces what appear as multiple events according to sleep_interval and
# update_threshold into a singular event.
if(  $diffInterval > $INTERVAL_THRESHOLD ){

if( $knockCount == 0 ){ $diffInterval = 0 }

if( $option ){
print "Knock: $knockCount ## last: [$currVal] curr: [$prevInterval] ";
print "difference is: $diffInterval\n";
}

push @baseKnocks, $diffInterval;
$knockCount++;

}# if the difference interval is greater than the threshold

$prevInterval = $currVal;

}#if checkknock passed

}#knockListen

sub readKnockFile {

open(KNCKFILE,"$ENV{HOME}/.knockFile") or die "no knock file: $!";

while(<KNCKFILE>){

if( !/^#/ ){

my @arrLine = split "_#_";
$knockHash{ $arrLine[0] }{ cmd }     = $arrLine[1];
$knockHash{ $arrLine[0] }{ comment } = $arrLine[2];

}#if not a comment line

}#for each line in file

close(KNCKFILE);

}#readKnockFile

sub compareKnockSequences {

my $countMatch = 0;  # record how many knocks matched

# for each knock sequence in the config file
for( keys %knockHash ){

# get the timings between knocks
my @confKnocks = split;

# if the count of knocks match
if( $knockCount eq @confKnocks ){

my $knockDiff = 0;
my $counter = 0;

for( $counter=0; $counter<$knockCount; $counter++ ){

$knockDiff = abs($confKnocks[$counter] - $baseKnocks[$counter]);
my $knkStr = "k $counter b $baseKnocks[$counter] ".
"c $confKnocks[$counter] d $knockDiff\n";

# if it's an exact match, increment the matching counter
if( $knockDiff < $MAX_KNOCK_DEV ){

if( $option ){ print "MATCH $knkStr" }
$countMatch++;

# if the knocks don't match, move on to the next pattern in the list
}else{

if( $option ){ print "DISSONANCE $knkStr" }
last;

}# deviation check

}#for each knock

}#if number of knocks matches

# if the count of knocks is an exact match, run the command
if( $countMatch eq @confKnocks ){
my $cmd = system( $knockHash{"@confKnocks "}{ cmd } );
if( $option ){ print "$cmd\n" }
last;

# otherwise, make the count of matches zero, in order to not reset
}else{
$countMatch = 0;
}

}#for keys

# if the match count is zero, exit and don't reset variables so a longer
# knock sequence can be entered and checked
if( $countMatch == 0 ){ return() }

# if a match occurred, reset the variables so it won't match another pattern
$knockCount = 0;
@baseKnocks = ();

}#compareKnockSequences

if( $option eq "-c" ){

print "create a knock pattern:\n";

$startTime = getEpochSeconds();  # reset time out start

while( $timeOut == 0 ){

$currTime = getEpochSeconds();

# check if there has not been a knock in a while
if( $currTime - $startTime > $MAX_TIMEOUT_LENGTH ){

$timeOut = 1;  # exit the loop

}else{

# if a knock has been entered before timeout, reset timers so
# more knocks can be entered

if( $knockCount != $knockAge ){
$startTime = $currTime;   # reset timer for longer delay
$knockAge = $knockCount;  # synchronize knock counts
}# if a new knock came in

}# if timer not reached

knockListen();
select(undef, undef, undef, $SLEEP_INTERVAL);

}#timeOut =0

if( @baseKnocks ){
print "place the following line in $ENV{HOME}/.knockFile\n\n";
for( @baseKnocks ){ print "$_ " }
print "_#_ (command here) _#_ <comments here>\n\n";
}#if knocks entered

}else{

# main code loop to listen for knocking and run commands
readKnockFile();

$startTime = getEpochSeconds();

while( $timeOut == 0 ){

$currTime = getEpochSeconds();

if( $currTime - $startTime > $LISTEN_TIMEOUT ){

$knockCount = 0;
@baseKnocks = ();
$startTime = $currTime;
if( $option ){ print "listen timeout - resetting knocks \n" }

}else{

if( $knockCount != $knockAge ){
$startTime = $currTime;   # reset timer for longer delay
$knockAge = $knockCount;  # synchronize knock counts
}# if a new knock came in

compareKnockSequences();

}#if not reset timeout

knockListen();

select(undef, undef, undef, $SLEEP_INTERVAL);

}#main knock listen loop

}# if create or listen for knocks