Code/tp-theft - Revision history

Maikel: added forgotten hash for comment

2014-01-22T04:15:15Z

added forgotten hash for comment

T33nkp4d: Aded checking and using power cord ac state for alarming

2010-11-20T12:05:24Z

Aded checking and using power cord ac state for alarming

Newacct at 19:23, 14 August 2010

2010-08-14T19:23:31Z

Thinker: v0.5.1 - silence BlueTooth stdout, comments

2007-02-23T18:57:32Z

v0.5.1 - silence BlueTooth stdout, comments

Thinker: Workaround: sox doesn't like duration <0.1sec

2007-02-22T23:26:32Z

Workaround: sox doesn't like duration <0.1sec

Thinker: Update comments

2007-02-22T22:00:37Z

Update comments

Thinker: v0.5.0: Add BlueTooth activation support + small cleanups

2007-02-22T21:57:13Z

v0.5.0: Add BlueTooth activation support + small cleanups

Show changes

Thinker: Moved from Script for theft alarm using HDAPS#A_comprehensive_script

2006-07-26T22:35:56Z

Moved from Script for theft alarm using HDAPS#A_comprehensive_script

New page

#!/usr/bin/perl
#
# tp-theft v0.4.0
# (http://thinkwiki.org/wiki/Script_for_theft_alarm_using_HDAPS)

# Provided under the GNU General Public License version 2 or later or
# the GNU Free Documentation License version 1.2 or later, at your option.
# See http://www.gnu.org/copyleft/gpl.html for the Warranty Disclaimer.

# This script uses the HDAPS accelerometer found on recent ThinkPad models
# to emit an audio alarm when the laptop is tilted. In sufficiently
# populated environments, it can be used as a laptop theft deterrent.
# Uses a state machine and some heuristics to reduce false alarms.
#
# By default the alarm will be activated only when the KDE screen saver is
# locked. If you you open the laptop lid (or press the lid button) shortly
# before or after the beginning of movement, the alarm will be suspended
# (except for a brief warning) and you will get a few seconds of grace to
# unlock the screen saver. You can disable this functionality by passing
# the "--arm" parameter, or by setting $use_kde=0 and $use_lid=0 .
# To control the sound and blinkenlights, see the variables below.

use strict;
use warnings;
use FileHandle;
use Time::HiRes qw(sleep time);

##############################
# Siren volume and content

# Alarm audio volume (0..100)
my $alarm_volume = 70;
# Alarm command (default: synthesize a siren for 1.0 seconds):
my $alarm_cmd = "sox -t nul /dev/null -t wav -s -w -c2 -r48000 -t raw - synth 1.0 sine 2000-4000 sine 4000-2000 | aplay -q -fS16_LE -c2 -r48000";
# my $alarm_cmd = "aplay keep_your_hands_off_me.wav";

# Warning audio volume (0..100)
my $warn_volume = 45;
# Alarm command (default: synthesize a biref siren):
my $warn_cmd = "sox -t nul /dev/null -t wav -s -w -c2 -r48000 -t raw - synth 0.05 sine 2000-4000 sine 4000-2000 | aplay -q -fS16_LE -c2 -r48000";
# my $warn_cmd = "aplay warning.wav";

# Set ibm_acpi volume (0..15), if ibm_acpi is loaded with "experimental=1".
# Combining $acpi_volume=15 and $alarm_volume=100 makes the alarm
# dangerously loud.
my $acpi_volume = 10;

# Blink system LEDs when alarm activated?
my $use_led = 'safe'; # 0=off, 'safe'=only LEDs whose state you can recover, 'all'=pretty blinkenlights!

# Blink ThinkLight when alarm activated?
my $use_light = 0; # 0=off, 1=on

##############################
# Activation control

# Tilt threshold (increase value to decrease sensitivity):
my $thresh = 0.20;
# Minimum movement duration between warning and alarm:
my $min_hold = 1.3;
# When armed, any movement triggers alarm. How long should it remain armed?
my $arm_persist = 6;

# Activate according to KDE screen saver? Otherwise, always active:
my $use_kde = 1;
# When screen saver locked, wait this long before activation:
my $kde_lock_delay = 8;

# Provide grace period if laptop lid is opened?
my $use_lid = 1;
# Opening a lid will grant this many seconds of grace (once):
my $lid_grace = 7;
# Lid must to be opened within this time to hold/pause alarm:
my $lid_grace_window = 8;
# Alarm will hold off this long when grace is available:
my $lid_hold = 3;
# After this many seconds of no movement, will allow grace again:
my $grace_relax = 15;

##############################
# Other setup vars

my $interval = 0.1; # sampling intervalm in seconds
my $depth = 10; # number of recent samples to analyze
my $verbose = 2; # 0=nothing, 1=alarms, 2=state transitions, 3=everything
my $kde_check_interval = 1.5; # KDE screen saver check is expensive

my $pos_file = '/sys/devices/platform/hdaps/position';
my $lid_file = '/proc/acpi/button/lid/LID/state';
my $led_file = '/proc/acpi/ibm/led';
my $light_file = '/proc/acpi/ibm/light';
my $bay_file = '/proc/acpi/ibm/bay';
my $volume_file = '/proc/acpi/ibm/volume'; # load ibm_acpi with experimental=1

my $alsactl = '/usr/sbin/alsactl';
my $amixer = 'amixer';
my $kdesktop_lock = '/usr/bin/kdesktop_lock';

##############################
# Utility functions

sub say {
my ($verb, $what) = @_;
print(gmtime().": $what\n") if $verb<=$verbose;
}

sub slurp { # read whole file
my ($filename) = @_;
local $/;
my $fh = new FileHandle($filename,"<") or return;
return <$fh>;
}

sub stddev { # standard deviation of list
my $sum=0;
my $sumsq=0;
my $n=$#_+1;
for my $v (@_) {
$sum += $v;
$sumsq += $v*$v;
}
return sqrt($n*$sumsq - $sum*$sum)/($n*($n-1));
}

my $alarm_file; # flags ongoing alarm (and also stores saved mixer settings)

sub sound_alarm {
# Sound alarm. Forks bash code which sets given volumes, runs the given
# command, and then restores the given volumes to their saved values.
my ($name, $volume, $acpi_volume, $cmd) = @_;
return if (defined($alarm_file) && -f $alarm_file);
say(1,$name);
$alarm_file = `mktemp /tmp/tp-theft-tmp.XXXXXXXX` or die "mktemp: $?";
chomp($alarm_file);
my ($acpi_vol_file, $acpi_vol_set, $acpi_vol_restore);
if ($_=slurp($volume_file) and m/^level:\s+(\d+)\n/) {
$acpi_vol_file = $volume_file;
$acpi_vol_set = "level $acpi_volume";
$acpi_vol_restore = "level $1";
if (m/^mute:\s+on$/m) {
$acpi_vol_set = "up,".$acpi_vol_set; # unmute first
$acpi_vol_restore .= ",mute"; # mute last
}
} else {
$acpi_vol_file='/dev/null'; $acpi_vol_set=''; $acpi_vol_restore='';
}
system('/bin/bash', '-c', <<"EOF")==0 or die "Failed: $?";
( trap \"echo '$acpi_vol_restore' > $acpi_vol_file; sleep 0.1;
$alsactl -f $alarm_file restore;
rm -f $alarm_file
\" EXIT HUP QUIT TERM
$alsactl -f $alarm_file store && # store ALSA
echo '$acpi_vol_set' > $acpi_vol_file && sleep 0.1 && # set ACPI
$amixer -q set Master $volume% unmute && # set ALSA Master
$amixer -q set PCM 100% unmute && # set alsa PCM
$cmd ) & # invoke command
EOF
}

##############################
# KDE screen saver lock check

if ($use_kde) { # Basic sanity check
`/sbin/pidof kdesktop`; $?==0 or die "Can't use KDE, it's not running.\n";
}

sub kdesktop_lock_status {
# See if kdesktop_lock is running and check its cmdline and automatic lock delay
my $bin = $kdesktop_lock;
my $pids = `/sbin/pidof $bin`;
return 'off' unless $?==0;
for my $pid (split(/\s+/,$pids)) {
next unless $pid =~ m/^\d+$/;
# Attached to display ":0" or "localhost:0"?
my $environ = slurp("/proc/$pid/environ") or next;
my $good=0; my $home;
for (split(/\x00/,$environ)) {
$good=1 if m/^DISPLAY=(localhost)?:0$/;
$home=$1 if m/^HOME=(.+)$/; # also remember its $HOME
}
next unless $good;
# Check command line
my $cmdline = slurp("/proc/$pid/cmdline") or next;
$cmdline =~ m/^[^\x00]+\x00(?:([^\x00]+)\x00)?/ or die "Cannot parse $bin command line\n";
if (!defined($1)) {
# Read KDE screensaver lock time
defined($home) or die "Cannot find HOME in environment of $bin process";
my $rc_path = "$home/.kde/share/config/kdesktoprc";
my $rc = new FileHandle($rc_path,"<") or die "Error opening $rc_path: $!";
while (<$rc>) { m/^LockGrace=(\d+)$/ and return ('auto', $1/1000.0); };
die "Cannot parse $rc_path";
} elsif ($1 eq '--forcelock') {
return "force";
}
}
return 'off';
}

my $last_kls_update = 0; # time of last update
my $last_kls = 'init'; # last state seen
my $last_kls_start; # when that state started

sub check_kde_lock {
# De/activate according to KDE screen saver:
my $now=time();
return if $now < $last_kls_update + $kde_check_interval;
my ($kls, $auto_delay) = kdesktop_lock_status();
$last_kls_update = time();
if ($kls ne $last_kls) {
$last_kls = $kls;
$last_kls_start = $now;
}
if ($kls eq 'off') { # no screen saver
return(0, 'KDE screen saver not locked');
} elsif ($kls eq 'auto') { # screen saver with automatic lock
if ($now >= $last_kls_start + $auto_delay + $kde_lock_delay) {
return(1, 'KDE screen saver is auto-locked');
}
} elsif ($kls eq 'force') { # screen saver with forced lock
if ($now >= $last_kls_start + $kde_lock_delay) {
return(1, 'KDE screen saver is forced-locked');
}
}
}

##############################
# Lid checking

if ($use_lid) { # sanity check
slurp($lid_file) or die "Can't use lid via $lid_file: $!";
}

my $last_lid_status = 'open';
my $last_lid_open = 0;

sub check_lid {
my $lid = slurp($lid_file) or return;
if ($lid =~ m/state: *open$/) {
$last_lid_open = time() if ($last_lid_status eq 'closed');
$last_lid_status = 'open';
} else {
$last_lid_status = 'closed';
}
return $last_lid_status;
}

##############################
# LED blinking

sub frac {
my ($x) = @_;
return $x-int($x);
}

sub led_activate {
return if $use_led eq '0';
my $ledf = new FileHandle($led_file,">");
if (!defined($ledf)) {
print "Cannot open $led_file, disabling LED indicator: $!\n";
$use_led = '0';
return;
}
$ledf->autoflush(1);
my $base = time()*2.5;
print $ledf '0 '.((frac($base)>0.7)?'on':'off')."\n"; # power
if ($use_led eq 'all') { # battery -- we can't recover these
print $ledf '1 '.((frac($base+0.50)>0.7)?'on':'off')."\n"; # battery, orange
print $ledf '2 '.((frac($base+0.25)>0.7)?'on':'off')."\n"; # battery, yellow
}
print $ledf '4 '.((frac($base)>0.7)?'on':'off')."\n"; # bay
print $ledf '7 '.((frac($base+0.725)>0.7)?'on':'off')."\n"; # standby
}

sub led_restore {
return if $use_led eq '0';
my $ledf = new FileHandle($led_file,">") or die "Cannot open $led_file: $!\n";
$ledf->autoflush(1);
print $ledf "0 on\n"; # power=on
if ($use_led eq 'all') { # battery -- we can't recover these
print $ledf "1 on\n";
print $ledf "2 on\n";
}
print $ledf "7 off\n"; # power=off
my $baydata = slurp($bay_file) or die "Cannot open $bay_file: $!\n";
my $is_bay = ($baydata =~ m/^status:\s*occupied$/m)?'on':'off';
print $ledf "4 $is_bay\n"; # bay
}

##############################
# ThinkLight blinking

sub light_activate {
return if $use_light eq '0';
my $lightf = new FileHandle($light_file,">");
if (!defined($lightf)) {
print "Cannot open $light_file, disabling ThinkLight indicator: $!\n";
$use_light = '0';
return;
}
my $base = time()/2;
print $lightf (check_lid() eq 'open' && ((frac($base)<0.1)?'on':'off'))."\n";
}

sub light_restore {
return if $use_light eq '0';
my $lightf = new FileHandle($light_file,">") or die "Cannot open $light_file: $!\n";
print $lightf "off\n"; # ThinkLight
}

##############################
# Main code

my $state;
my %state_names=(0 =>'disabled ',
0.5=>'activating ',
1 =>'active+grace',
2 =>'active ',
3 =>'hold+grace ',
4 =>'armed+grace ',
5 =>'hold ',
6 =>'armed ',
7 =>'armed-force ' );
my $state_end = 0;
my $last_tilt = 0;
my $arm_forced = 0;
my (@XHIST, @YHIST); # sensor history

sub set_state {
my ($st, $why) = @_;
say(2, "state=[".$state_names{$st}."] ($why)");
(@XHIST, @YHIST) = () if $st==0.5;
led_restore() and light_restore() if defined($state) && $st==0;
$state = $st;
}

sub get_pos {
my $pos = slurp($pos_file) or die "Can't open HDAPS file $pos_file: $!\n";
$pos =~ m/^$(-?\d+),(-?\d+)$$/ or die "Can't parse $pos_file content\n";
return ($1,$2);
}

for (@ARGV) {
m/^--arm/ && do { $arm_forced=1; $use_lid=0; $use_kde=0; last; };
die "Unknown parameter\n";
}

set_state($use_kde?0:0.5, "init");

eval {

$SIG{'HUP'}=$SIG{'INT'}=$SIG{'ABRT'}=$SIG{'QUIT'}=$SIG{'SEGV'}=$SIG{'TERM'} = sub { die "signal\n" };

while (1) {
sleep(($state==0 && $use_kde) ? $kde_check_interval : $interval);

# Check screensaver and lid:
check_lid() if $use_lid;
if ($use_kde && (my ($op, $why) = check_kde_lock())) {
set_state(0.5, $why) if $op==1 && $state==0;
set_state(0, $why) if $op==0 && $state>0;
}
next unless $state>0;

# Collect and analyze sensor data:
my $now = time();
my $tilted;
my ($x,$y) = get_pos;
push(@XHIST,$x); push(@YHIST,$y);
if ($state>0.5) {
shift(@XHIST); shift(@YHIST);
my $xdev = stddev(@XHIST);
my $ydev = stddev(@YHIST);
say(3,"X: v=$xdev (".join(',',@XHIST).") Y: v=$ydev (".join(",",@YHIST).")");
$tilted = ($xdev>$thresh || $ydev>$thresh);
$last_tilt = $now if $tilted;
}

# Decide: state machine transitions
if ($state==0.5) { # activating
if ($#XHIST >= $depth && $#YHIST >= $depth) {
set_state($arm_forced?7:$use_lid?1:2, "finished data collection");
}
} elsif ($state==1) { # active+grace
if ($tilted) {
set_state(3, "motion detected, holding for $lid_hold seconds, open lid for grace");
$state_end = $now + $lid_hold;
sound_alarm("WARNING", $warn_volume, $acpi_volume, $warn_cmd);
}
} elsif ($state==2) { # active
if ($tilted) {
set_state(5, "motion detected, holding for $min_hold seconds");
$state_end = $now + $min_hold;
sound_alarm("WARNING", $warn_volume, $acpi_volume, $warn_cmd);
} else {
if ($use_lid && ($now > $last_tilt + $grace_relax )) {
set_state(1, "$grace_relax seconds since last motion, so allowing grace again");
}
}
} elsif ($state==3) { # hold+grace
if ($now < $last_lid_open + $lid_grace) {
set_state(5, "lid opened, holding for $lid_grace seconds grace period");
$state_end = $now + $lid_grace;
} elsif ($now >= $state_end) {
my $delta = $lid_grace_window - $lid_hold;
$state_end = $now + $delta;
set_state(4, "hold ended, arming but allowing grace for $delta more seconds");
}
} elsif ($state==4) { # armed+grace
if ($now < $last_lid_open + $lid_grace) {
set_state(5, "lid opened, holding for $lid_grace seconds grace period");
$state_end = $now + $lid_grace;
} elsif ($now >= $state_end) {
set_state(6, "grace window ended");
}
} elsif ($state==5) { # hold
if ($now >= $state_end) {
set_state(6, "hold ended, arming");
}
} elsif ($state==6) { # armed
if ($now > $last_tilt + $arm_persist) {
set_state(2, "no motion for $arm_persist seconds, unarming");
}
}

# LEDs:
if ($state>0) {
led_activate(); light_activate();
}

# Alarm:
if (($state==4 || $state==6 || $state==7) && $tilted) {
sound_alarm("ALARM", $alarm_volume, $acpi_volume, $alarm_cmd);
}
}

};

print "Shutting down.\n" if $verbose>1;
led_restore() and light_restore() if ($state>0);
die "$@" if $@;

@@ Line 324: / Line 324: @@
 ##############################
-AC state checking
+# AC state checking
 my $ac_state;
 sub read_ac_state {

@@ Line 1: / Line 1: @@
 #!/usr/bin/perl
+#
@@ Line 618: / Line 619: @@
 bluetooth_restore();
 die "$@" if $@;

@@ Line 1: / Line 1: @@
 #!/usr/bin/perl
+#
-# tp-theft v0.5.0
+# tp-theft v0.5.1
 # (http://thinkwiki.org/wiki/Script_for_theft_alarm_using_HDAPS)
@@ Line 22: / Line 22: @@
 # There is also an option to track a BlueTooth device (e.g., a mobile phone).
 # In this case, the alarm is activated (and optionally, the KDE desktop is
-# locked) whenever the device is turned off or too distant for a given time,
+# locked) whenever the device is turned off or too distant for a given period,
-# and deactivated when the BlueTooth is nearby. You need to provide the
+# and deactivated when the BlueTooth device is nearby. You need to provide the
 # device's BD address. If both KDE screen saver and BlueTooth checking are
 # enabled, then the alarm will be activated when *either* the screensaver
@@ Line 424: / Line 424: @@
                  $bt_pipe->writer();
                  $bt_pipe->autoflush(1);
-                 open(STDOUT,">/dev/null");
+                 open(STDOUT, ">/dev/null");
                  while(1) {
                      # Is the BlueTooth token reachable?

@@ Line 21: / Line 21: @@
+#
 # There is also an option to track a BlueTooth device (e.g., a mobile phone).
-# In this case, the alarm is activated whenever the device is outside BlueTooth
+# In this case, the alarm is activated (and optionally, the KDE desktop is
-# range (or turned # off) for a given time, and deactivated when the BlueTooth
+# locked) whenever the device is turned off or too distant for a given time,
-# device is within range. You need to provide the device's BD address.
+# and deactivated when the BlueTooth is nearby. You need to provide the
-# If both KDE screen saver and BlueTooth checking are enabled, then the alarm
+# device's BD address. If both KDE screen saver and BlueTooth checking are
-# will be activated when *either* the screensaver is enabled or the BlueTooth
+# enabled, then the alarm will be activated when *either* the screensaver
-# device is amiss.
+# is enabled or the BlueTooth device is amiss.
+#
 # To control the sound and blinkenlights, and adjust the alarm activation

@@ Line 65: / Line 65: @@
 my $use_light = 0;  # 0=off, 1=on
 ##############################
 # Activation control
@@ Line 125: / Line 127: @@
 my $volume_file = '/proc/acpi/ibm/volume'; # load ibm_acpi with experimental=1
 my $bluetooth_file = '/proc/acpi/ibm/bluetooth'; # load ibm_acpi with experimental=1
 my $alsactl = '/usr/sbin/alsactl';
@@ Line 320: / Line 323: @@
+}
 ##############################
@@ Line 497: / Line 514: @@
 my $arm_forced = 0;
 my (@XHIST, @YHIST); # sensor history
 sub set_state {
@@ Line 554: / Line 573: @@
          $last_tilt = $now if $tilted;
+     }
      # Decide: state machine transitions
@@ Line 607: / Line 632: @@
+     }
      # Alarm:
-     if (($state==4 || $state==6 || $state==7) && $tilted) {
+     # included initpower state
          sound_alarm("ALARM", $alarm_volume, $acpi_volume, $alarm_cmd);
+     }

@@ Line 50: / Line 50: @@
 my $warn_volume = 45;
 # Alarm command (default: synthesize a biref siren):
-my $warn_cmd = "sox -t nul /dev/null -t wav -s -w -c2 -r48000 -t raw - synth 0.05 sine 2000-4000 sine 4000-2000 | aplay -q -fS16_LE -c2 -r48000";
+my $warn_cmd = "sox -t nul /dev/null -t wav -s -w -c2 -r48000 -t raw - synth 0.10 sine 2000-4000 sine 4000-2000 | aplay -q -fS16_LE -c2 -r48000";
 # my $warn_cmd = "aplay warning.wav";