You can conveniently set “modes”, which are settings with states you can define and use. You can then fire events upon state change, and so are they very useful to define some sort of macros.

A few examples :

• the “Security” mode could be “on” or “off” : setting it “on” would close the shutters and activate the alarm system; setting it “off” would do the opposite;
• the “Heating” mode could be “day”, “night”, “frost protection only” : setting it on “day” would set the target temperature to 20⁰C, “night” to 15⁰C and “frost protection only” to 7⁰C
• the “Cinema” mode could be “on” or “off” : setting it to “on” would close the blinds and dim the lights; “off” would bring those back to their former states.

This post will show how to setup a mode, we’ll use the “Heating” mode described above as an example.

Coding a mode

The first thing to know is that a mode is nothing but a Generic_Item. By convention, it’s simpler to use an identifier starting by “mode_”.
Here’s the sample code for the “Heating” mode (click to expand):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

$mode_heating = new Generic_Item;
$mode_heating->set_states('day', 'night', 'off');
 
if (state_changed $mode_heating) {
        my $heating_mode_state;
        $heating_mode_state = state $mode_heating;
        main::print_log "Mode = ", $heating_mode_state;
        if ($heating_mode_state eq "day") {
                $thermostat_bureau->setTarget(18);
                $thermostat_living->setTarget(20);
        }
 
        if ($heating_mode_state eq "night") {
                $thermostat_bureau->setTarget(13);
                $thermostat_living->setTarget(15);
        }
 
        if ($heating_mode_state eq "off") {
                $thermostat_bureau->setTarget(7);
                $thermostat_living->setTarget(7);
        }
}
 
set $mode_heating "night"       if time_cron '00 20 * * *';
set $mode_heating "day"         if time_cron '00 06 * * *';

This code is pretty simple : MisterHouse will take all variable definitions and object creations and will execute them, then put everything else in its main event loop. So here the mode is created and then, in the main event loop, actions will be taken if the state of the mode is changed.
It will also switch the state of the heating mode to day at 6am and to night at 8pm as defined with the “time_cron” functionnality.

Integrating the mode within the web interface

To have this mode show up in the web interface, you’ll need to alter the mh/web/ia5/modes/main.shtml and add the following row at the end of the “table” tag :

1
2
3

<tr>
  <td align='middle'> <!--#include file="/bin/button_toggle.pl?mode_heating&/ia5/modes/main.shtml"--> </td>
</tr>

If the GD graphics library is installed on your system, is supporting JPEG files and you enabled its use by MisterHouse (gd = 1 in mh.private.ini), then MisterHouse will generate and display a graphical button with the current state of the mode. If not you’ll get a text link. No matter what, you can cycle through the different states defined for the mode by simply clicking on it.

If you’d like to have your own graphical buttons, simply place them into the “data” dir (data_dir configuration item of the mh.private.ini) and name them following the convention “modename_item_state.jpg”. For my example modename = mode_heating, and state are “day”, “night” and “frost”, so I’d need the files “mode_heating_item_day.jpg”, “mode_heating_item_night.jpg” and “mode_heating_item_frost.jpg”.

References

• mh/code/common/mh_control.pl : definition of core MisterHouse modes like mode_mh (normal/mute/offline), mode_vacation (on/off), mode_security (armed/unarmed), mode_sleep (awake/sleeping parents/sleeping kids). You can use those as working examples for your own modes.
• mh/web/ia5/modes directory : html files for the “modes” menu web page.
• mh/web/bin/button.pl : script which returns the path to the file for a button and generate it if needed.
• mh/web/bin/button_toggle.pl : script which generates a link which will toggle an object upon click

MisterHouse : Setting up “modes” is a post from: Tech@Sakana - A sysadmin's blog

Here is the script. It’s pretty simple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#! /usr/bin/perl
 
use strict;
use warnings;
 
use WWW::Facebook::API;
use Text::vCard::Addressbook;
use Date::Parse;
 
my $client = WWW::Facebook::API->new(
	desktop => 1,
	api_key => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
	secret  => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
);
 
my $token = $client->auth->create_token;
 
my $url = $client->get_login_url( auth_token => $token, req_perms => 'friends_birthday' );
system "firefox", $url;
sleep 15;
 
$client->auth->get_session($token);
my $response = $client->fql->query(query => 'select first_name, last_name, birthday from user where uid in (select uid2 from friend where uid1=me())');
 
my $ab = text::vcard::addressbook->new;
# processes each contact and creates a vCard for it {{{
foreach my $contact (@$response) {
	my $vc = $ab->add_vcard;
 
	my $fn = $contact->{first_name} || "";
	my $ln = $contact->{last_name} || "";
	$ln = uc $ln;
	my $bd = $contact->{birthday} || "";
	$bd =~ s/,//g;
 
	$vc->fullname($fn . " " . $ln);
	if ($bd) {
		my ($ss,$mm,$hh,$day,$month,$year,$zone) = strptime($bd);
		$vc->bday(join("-", (1900 + ($year || " "), $month + 1, $day)));
	}
}
# }}}
print $ab->export();
$client->auth->logout;

This is intended as a sample code for using the WWW::Facebook::API perl module (there are way too few working examples out there). Let me know if you need complementary explanations about anything.

The only thing I really need to figure out now is how to proceed if I ever wanted to distribute this code without giving away the application secret. There is a rather good general explanation of the authentication process of a facebook desktop application, but I couldn’t find a working sample code to get started with. If you do know how to do that, please share in the comments.

Facebook API : Exporting your friends birthdays into vCards format is a post from: Tech@Sakana - A sysadmin's blog

1
2
3
4
5
6
7
8
9
10
11
12

kattoo@roadrunner /files/toSave/home/kattoo/Downloads $ perl -ane '$c{$F[0]}++; END {print map {$_ . "\t->\t" . $c{$_} . "\n"} (sort {$c{$b} <=> $c{$a}} keys %c)[0..9]}' sakana.fr-28-02-2010.log 
XX.XX.XX.XXX	->	163
XX.XXX.XXX.XXX	->	150
XXX.XXX.XX.XX	->	136
XXX.XX.XXX.XXX	->	134
XX.XXX.XXX.XX	->	116
XX.XXX.XXX.XXX	->	110
XX.XX.XXX.XX	->	104
XX.XXX.XXX.XXX	->	90
XX.XXX.X.XXX	->	75
XXX.XXX.XX.XXX	->	72
kattoo@roadrunner /files/toSave/home/kattoo/Downloads $

Short explanation of the command line switches :

• -a : turns on autosplit, the different fields will then be accessible in the @F variable
• -e : specifies the code to execute
• -n : wraps that code into a loop for each text line of the file to process from the standard input or the files specified on the command line

This is equivalent to Nils’ approach in awk but you know, I’ve always been partial to Perl

Feel free to suggest any improvement… I know there must be many !

Suggested reading

• Programming Perl (3rd Edition) (on Amazon) : The reference guide for Perl programming, written by Perl Gods (Larry Wall, Tom Christiansen, John Orwant).
• Use command-line Perl to make UNIX administration easier (on techrepublic) : Short intro about perl 1-liners

Perl : Counting occurences of IP addresses in Apache logs is a post from: Tech@Sakana - A sysadmin's blog

In this script, we use the JSON Twitter API. Perl has a JSON module to make parsing or JSON streams a bliss. I also used formats for easy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#! /usr/bin/perl
 
use strict;
use warnings;
 
use JSON;
use Encode;
 
my $json = new JSON;
my $json_stream = join "", map {decode("UTF-8", $_)} <>;
 
my $mentions = $json->decode($json_stream);
 
foreach my $mention (@$mentions) {
	my $screen_name = encode("UTF-8", $mention->{user}->{screen_name});
	my $text = encode("UTF-8", $mention->{text});
	format =
@<<<<<<<<<<<<<<    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$screen_name,      $text
                   ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ~~
				   $text
.
	write;
}

You’ll have to run it as demonstrated below :

1
2
3
4
5
6
7
8
9

kattoo@roadrunner /files/toSave/home/kattoo $ curl -sS -u YourLoginHere:YourPasswordHere http://twitter.com/statuses/mentions.json | twitter-mentions.pl 
divarvel           @killermouse0 mon /boot est pas dans une
                   partition à part, et pour une install en
                   chroot je ne sais pas quoi faire (un autre
                   /boot ?)
fenice             @killermouse0 merci, c'est sympa. Tu tourne
                   sous Gentoo ?
[...]
kattoo@roadrunner /files/toSave/home/kattoo $

That’s all ! Of course this piece of code could use a lot of improvements, but this is intended as a kickstart sample… The curl part could have been directly integrated into the Perl code, but I like to keep it simple.

Now off to integrate this in my Conky layout

And by the way, you’ll find my twitter account on the right, in the “Follow me” section. Feel free to add me for updates !

Worth reading

• Twitter : Send free SMS messages to your friends : now you can do this from the command line
• Scripting Twitter with cURL
• Scripting Twitter with Perl + LWP : a script in Perl doing the same thing (much simpler).
• Perl+Twitter : Getting @mentions from command line

Perl+Twitter : Getting @mentions from command line is a post from: Tech@Sakana - A sysadmin's blog

So here is a simple snippet demonstrating how to get the price of a stock :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#! /usr/bin/perl
 
use strict;
use warnings;
use Finance::Quote;
 
my $q = Finance::Quote->new();
 
my @tickers = ("CS.PA", "DEXB.PA", "AF.PA", "VIE.PA", "KEYYO.PA");
my $s = $q->fetch("yahoo_europe", @tickers);
 
my $stocks;
 
while (my ($k, $v) = each %$s) {
	my $stock;
	my $label;
 
	($stock, $label) = (split $;, $k)[0, 1];
	$stocks->{$stock}->{$label} = $v;
}
 
my @data = ();
foreach (@tickers) {
	if (not $stocks->{$_}->{success}) {
		push @data, { name => $_, price => "N/A"};
	} else {
		push @data, $stocks->{$_};
	}
}
my @sorted = sort { $a->{name} cmp $b->{name} } @data;
@data = undef;
 
print sprintf "% -20s %s\n", "STOCK", "PRICE";
foreach (@sorted) {
	print sprintf "% -20s % 7.2f\n", $_->{name}, $_->{price};
}

The execution will provide something like that :

1
2
3
4
5
6
7
8

kattoo@roadrunner ~/bin $ ./get-stocks.pl 
STOCK                PRICE
AIR FRANCE - KLM       11.35
AXA                    16.64
DEXIA                   4.87
KEYYO                   3.30
VEOLIA ENVIRONN.       22.70
kattoo@roadrunner ~/bin $

That’s pretty simple so I won’t go into more details (feel free to ask if you need clarifications).

I’ve already added it into my conky layout with an execpi directive, and it works like a charm

Perl : Using the Finance::Quote module to get your stock prices is a post from: Tech@Sakana - A sysadmin's blog

D-Bus (Desktop Bus) is a simple inter-process communication (IPC) system for software applications to communicate with one another.

This post provides a simple code snippet in Perl to help you getting started with D-Bus programming.

D-Bus is used by many applications to provide users with a more tightly integrated desktop environment. Basically, an application can use D-Bus to provide services as well as to notify other application when a specific event occurs.

For example, the instant messaging client Pidgin will send a signal on D-Bus when a buddy on the contact list will connect. An application listening for this signal on the D-Bus pick it up (think inter-process messages) and then use D-Bus to ask extra informations to Pidgin about this buddy (think remote procedure call).

As I wanted to experiment with D-Bus, I’ve put this little example in practice. The code is pretty much self explanatory. It is coded in Perl as this is the language I use the most. Besides there are already plenty of examples of D-Bus programming in Python, but not so many in Perl.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#! /usr/bin/perl
 
use strict;
use warnings;
 
use Net::DBus;
use Net::DBus::Reactor;
 
# There is the system bus and the session bus. Here we are
# interested in the session bus
my $bus = Net::DBus->session;
 
# we connect the services Pidgin offers through D-Bus
my $purple = $bus->get_service('im.pidgin.purple.PurpleService');
my $object = $purple->get_object('/im/pidgin/purple/PurpleObject', 'im.pidgin.purple.PurpleInterface');
 
# we register a signal handler for when a connection occurs
$object->connect_to_signal('BuddySignedOn',
    sub {
        my $buddyId = shift;
        print "BuddySignedOn:", $object->PurpleBuddyGetAlias($buddyId), "\n";
    }
);
 
# and we start the main loop where the events are processed
my $reactor = Net::DBus::Reactor->main();
$reactor->run();
exit(0);

So all in all it makes it easy to offer the user an integrated environment thanks to D-Bus.

Imagine that, every time a new song is played in your music player, a signal is sent on the bus and your instant messaging client picks it up to display it in your status ? Easy to do with D-Bus ! And of course there are endless possibilities to make applications work together !

D-Bus introduction in Perl is a post from: Tech@Sakana - A sysadmin's blog

You can set the expire_logs_days variable in your my.cnf file, which will set the number of days MySQL will keep those binary log files.

This is the longest time a MySQL replication slave can lag behind the master. If for a reason the slave is not able to replicate for more than this duration, then it won’t be able to catch back (you will have to get back data from the server one way or another)

To clean the binary log files you can use the “PURGE MASTER LOGS” SQL command which can delete binary logs before a specified date or till a specified binary log file.

To see the binary log files on the server, you can use the “SHOW BINARY LOGS” SQL command.

At last, to know up to which file you could delete the binary log files, you can run the “SHOW SLAVE STATUS” on each replication slave to see which binary log file they are using, and delete up to the oldest of them.

MySQL : binary log files is a post from: Tech@Sakana - A sysadmin's blog

This little Perl one-liner can get handy when you need to translate “time in seconds since the Epoch” (for example in logs) to local time :

% perl -e 'print scalar(localtime(1202484725)), "\n";'
Fri Feb  8 16:32:05 2008
%

This was pretty useful today when browsing through Nagios event logs, where times are given in seconds from the Epoch.

By the way, the Epoch is defined as 00:00 UTC on January, 1st, 1970.

Perl : Convert time from Epoch to local time is a post from: Tech@Sakana - A sysadmin's blog

If not, you might want to start there for a little context.

I finally wrote and released on CPAN a Perl module which will help to automate cell phone operations such as saving/restoring the phonebook or sending an SMS.

Examples are included in the documentation. I believe I made it easy to use, but let me know if I’m wrong .

Features will be added on demand (if possible of course ).

The module is Device::Modem::GSM.

Perl : A module to play with a GSM mobile is a post from: Tech@Sakana - A sysadmin's blog

Doesn’t provide hints about how to unlock a GSM cell phone though

Existing tools

As usual it started with what seemed to be a simple need : I wanted to backup the contacts SIM card’s memory. I installed and tried various pieces of software with various but consistently disappointing results :

• kmobiletools : neat GUI, able to load the phonebook, but no option to export it to a file or restore it (but it works great if you want to send SMS from your computer with your mobile attached)
• kandy : nice interface, and is supposed to be able to sync your KDE AddressBook … but as far as my test went, it was not able to connect to my cell phone (maybe it will work with yours)
• xgsm / gsmlib : this one’s GUI is ugly, but at least it was possible to connect to the cell phone and save the phonebook to a file… but unfortunately it failed to restore it !!!
• KitchenSync was supposed to be a kind of universal sync tool, but as far as I’m concerned I didn’t manage to get anything out of it

You might first give a try to those tools and the others, they didn’t work for me but it doesn’t mean it won’t work for you !

DIY approach

Connecting the data cable

First let’s plug that data cable you bought for your cell phone from any mobile phone shop or from ebay.
Here’s what shows up with a dmesg :

spaghetti:~/$ dmesg
[492737.436000] usb 2-2: new full speed USB device using uhci_hcd and address 5
[492737.604000] usb 2-2: configuration #1 chosen from 1 choice
[492737.604000] cp2101 2-2:1.0: cp2101 converter detected
[492737.720000] usb 2-2: reset full speed USB device using uhci_hcd and address 5
[492737.868000] usb 2-2: cp2101 converter now attached to ttyUSB0
spaghetti:~/$

Looking up in google to know what is a CP2101 … This “USB data cable” is just a USB attached Serial Adapter (RS232 interface), which you can use like any other serial port under linux and which is now attached to /dev/ttyUSB0.

Connecting to the cell phone over this serial port

What then came to my mind is to use a terminal emulator capable of talking over a serial line. There are many such tool (minicom, kermit, hyperterminal … pick your favorite one). I tend to use cu for this purpose.

spaghetti% cu -h -s 38400 -l /dev/ttyUSB0
Connected.

• -h : turns on local echo (for you to see what you type in)
• -s : chooses the speed
• -l : chooses the tty matching the serial port you want to use

Trying a few commands

Some more googling and it turns out that one talks to his GSM cell phone as one would talk to those old RTC modems, using “AT-commands”. Those AT-commands are fairly standardized in the GSM specifications.
For example, here is how to seek an entry from the phonebook (“PB“) on the SIM card (the “SM” storage). Note that the ^M are the enter I type in :

spaghetti% cu -h -s 38400 -l /dev/ttyUSB0
Connected.
AT+CPBS="SM"^M
OK
AT+CPBR=13^M
+CPBR: 13,"33123456789",145,"Some Dude"
OK

We first selected the phonebook storage “SM” (the SIM card) and then fetched the 13th record out of it. The 145 which came along means the phone number is in international form (you have to add a “+” ahead of it when dialing).
Let’s write an entry :

AT+CPBW=61,"1234",129,"Name Dude"^M
OK
AT+CPBR=61^M
+CPBR: 61,"1234",129,"Name Dude"

Now we could send an SMS :

AT+CMGF=1^M
OK
AT+CMGS="+33123456"^M
> Did you get that ?^Z
+CMGS: 0
OK

First we specify that the SMS will be in “text format” with the AT+CMGF command. Then we send the SMS with the AT+CMGS command. First the number, then the text which is terminated with a ^Z.

Scripting, anyone ?

Of course, you might want to automate this all. You might want to backup / restore your SIM card, send an SMS from a script and so on …
For such purposes, there is a Perl module Device::Modem which will let you send AT-commands and get results very simply. And I am currently writing the Device::Modem::GSM module which will make it easy to interact with a GSM mobile phone.

References

This post barely scratches the surface of what you can do by using AT-commands with your mobile. You can read about all the other commands in the GSM reference on AT-commands, which you’ll find on the internet with a wisely built search query.

Developers’ home runs a nice technical tutorial about SMSes too.

Question to the readers

As I said, I am currently writing a Perl module to simplify GSM automation. I had in mind phonebook operations and SMS sending … What other features would you like to see implemented ?

Your ideas in the comments !

Linux + GSM : How to access your cell phone innards with Linux is a post from: Tech@Sakana - A sysadmin's blog