Rwaaren: /* Accessing device statuses in Domoticz */

2020-06-12T19:38:16Z

Accessing device statuses in Domoticz

New page

==Introduction==
Perl may not be natively installed in the Domoticz binary, but it can be easily and extensively used with Domoticz if installed separately on your system.
Please remember that on Linux, any scripts need execution rights (chmod +x) and read rights and that line-endings should be UNIX-friendly (<LF> only).
Please also remember that any script should specify the correct interpreter path on the very first line of the file (shebang line). For Perl :

#!/usr/bin/perl

You can run a perl script from the 'On Action:' or 'Off Action:' parameter of a switch. As an example:

script://coolscript.pl 0

where 'coolscript.pl' is a perl file in the '/home/pi/domoticz/scripts' folder and the '0' (or whatever) is an example parameter that the perl script will access via its @ARGV array.

Be aware, however, that Domoticz will '''wait''' for this script to finish executing before it continues. This means that if there are any long loops with e.g. sleep statements in the perl script then your Domoticz event queue will be severely delayed. A simple way to get around this is to wrap the call to the perl script inside a bash script that uses the '&' notation to spawn off a subprocess to run the perl and return immediately.

In your scripts directory, create a file called 'exec.sh' with the following content:

#! /bin/sh
/usr/bin/perl /home/pi/domoticz/scripts/$1.pl $2 $3 > /dev/null 2>&1 &

You can now use the following syntax to call up the actual perl script as follows:

script://exec.sh coolscript 0

This way, control is immediately returned to Domoticz while your perl script runs in the background. It can still interact with Domoticz using JSON calls as per usual, it's just running quietly.

== Accessing device statuses in Domoticz ==
The essence of interacting with Domoticz from a perl script is by using the JSON-call possibilities (which are documented here: [[JSON]https://www.domoticz.com/wiki/Domoticz_API/JSON_URL's]. You can make these calls from perl via e.g. the CPAN modules 'LWP::UserAgent' and 'JSON::RPC::Client', while modules such as 'JSON::XS' make decoding the returned JSON easy. Here's an example of switching a light on or off from perl:

#!/usr/bin/perl

no warnings 'uninitialized';
use LWP::UserAgent;

$url{domo} ='http://192.168.1.12:8080';

$idx =301;
$cmd ='On'; # or 'Off'

$switch_url = $url{domo}.'/json.htm?type=command&param=switchlight&idx='.$idx.'&switchcmd='.$cmd;
$ua=LWP::UserAgent->new; $ua->timeout(5); $res=$ua->put($switch_url);
unless ($res->is_success) { warn $res->status_line };

or to retrieve the status of a switch from perl:

#!/usr/bin/perl

no warnings 'uninitialized';
use LWP::UserAgent;
use JSON::XS;

$url{domo} = 'http://192.168.1.12:8080';

$idx = 301;

$ua = LWP::UserAgent->new; $ua->timeout(5);
$retrieve = $ua->get($url{domo}.'/json.htm?type=devices&rid='.$idx);
$res = $retrieve->decoded_content;
if ($retrieve->is_success) { $jres = JSON::XS->new->allow_nonref->decode($res) } else { warn $retrieve->status_line };
$state = $$jres{result}[0]->{Status}; # 'On', 'Off', 'Open', 'Closed', etc

An example of using JSON::RPC::Client is provided here [[LMS] https://www.domoticz.com/wiki/Logitech_Media_Server#Audio_Alerts_via_Squeezebox_Players]

=== Further examples ===
This script is the basis of interacting with Domoticz, because good practice dictates that you should test current device status before performing an action (no need to change the state to something it's already at). All the scripts below will rely on this building block.

=== Prerequisite ===
sudo apt-get install libjson-perl libdatetime-perl libwww-perl

=== Script example ===

liststatuses.pl
<syntaxhighlight lang="perl">
#!/usr/bin/perl
use v5.14;
use LWP::Simple; # From CPAN
use JSON qw( decode_json ); # From CPAN
use Data::Dumper; # Perl core module
use strict; # Good practice
use warnings; # Good practice
use utf8;
use feature qw< unicode_strings >;
my $IP="192.168.0.24";
my $PORT="8080";
my $trendsurl = "http://$IP:$PORT/json.htm?type=devices&filter=all&used=true&order=Name";
my $json = get( $trendsurl );
die "Could not get $trendsurl!" unless defined $json;
# Decode the entire JSON
my $decoded = JSON->new->utf8(0)->decode( $json );
# you'll get this (it'll print out); comment this when done.
#print Dumper $decoded_json;
my @results = @{ $decoded->{'result'} };
foreach my $f ( @results ) {
if ($f->{"SwitchType"}) {
print $f->{"idx"} . " " . $f->{"Name"} . " " . $f->{"Status"} . "\n";
} elsif ($f->{"Type"} eq "Group") {
print $f->{"idx"} . " " . $f->{"Name"} . " " . $f->{"Status"} . "\n";
} else {
print $f->{"idx"} . " " . $f->{"Name"} . " " . $f->{"Data"} . "\n";
}
}
</syntaxhighlight>

== Ping several machines ==

I started pinging machines from LUA but it quickly appeared that it made shift the clock for time scripts in LUA because of ping timeout wait if a device was absent. Thus I removed the scripts and added a perl script run from crontab that achieves the same and keeps the LUA script time working seamlessly...

Please remember to configure the couple (idx,IP) where idx is the device number of the virtual/dummy light-switch associated.

=== Prerequisite ===

sudo apt-get install libjson-perl libdatetime-perl libwww-perl

=== Proposed Crontab entry ===

I propose to run it every 2 minutes

*/2 * * * * /home/pi/ping_by_ip.pl 2>&1 >> /dev/null

=== Script example ===
ping_by_ip.pl
<syntaxhighlight lang="perl">
#!/usr/bin/perl
use v5.14;
use LWP::Simple; # From CPAN
use JSON qw( decode_json ); # From CPAN
use Data::Dumper; # Perl core module
use strict; # Good practice
use warnings; # Good practice
use utf8;
use feature qw< unicode_strings >;
#Change settings below to your server
my $IP="192.168.0.24";
my $PORT="8080";
# PUT your devices here such as it shows their idx (swichlight) and IP
my %IP=(39=>'192.168.0.23',
40=>'192.168.0.22',
10=>'192.168.0.25');
my $trendsurl = "http://$IP:$PORT/json.htm?type=devices&filter=all&used=true&order=Name";
my $json = get( $trendsurl );
die "Could not get $trendsurl!" unless defined $json;
# Decode the entire JSON
my $decoded = JSON->new->utf8(0)->decode( $json );
my @results = @{ $decoded->{'result'} };
my @tab;
foreach my $f ( @results ) {
if ($f->{"SwitchType"}) {
$tab[$f->{"idx"}]=$f->{"Status"};
}
}
foreach my $k (keys %IP) {
my $ip=$IP{$k};
my $res=system("sudo ping $ip -w 3 2>&1 > /dev/null");
#print "-->".$k." ".$res." ".$tab[$k]."\n";
if (($res==0)&&($tab[$k] eq 'Off')) {
print "$k is On\n";
`curl -s "http://192.168.0.24:8080/json.htm?type=command&param=switchlight&idx=$k&switchcmd=On"`;
} elsif (($res!=0)&&($tab[$k] eq 'On')) {
print "$k is Off\n";
`curl -s "http://192.168.0.24:8080/json.htm?type=command&param=switchlight&idx=$k&switchcmd=Off"`;
} else {
print "do nothing: $k is ".$tab[$k]."\n";
}
}
</syntaxhighlight>

== Accessing sqlite3 ==

=== Prerequisite ===

sudo apt-get install libdbd-sqlite3-perl libdbi-perl sqlite3

=== Script example ===

use DBI;
my $dbh = DBI->connect(
"dbi:SQLite:dbname=domoticz.db",
"",
"",
{ RaiseError => 1 },
) or die $DBI::errstr;
my $sth = $dbh->prepare( "SELECT * FROM DeviceStatus LIMIT 5" );
$sth->execute();

my $row;
while($row = $sth->fetchrow_hashref()) {
print "$row->{Id} $row->{HardwareId} $row->{Name}\n";
}
#$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
# VALUES (3, 'Teddy', 23, 'Norway', 20000.00 ));
#$rv = $dbh->do($stmt) or die $DBI::errstr;
$sth->finish();
$dbh->disconnect();

== Pachube / Cosm / Xively ==

Posting data to Xively can be interesting in the IoT (Internet of Things) approach, and maybe you are already doing so for some devices.

Here is a simple way that extracts all sensor values, simple or multiple, makes a bundle and senda it to Xively to create/update Channels of an existing device.

To achieve this we had to remove spaces and reserved chars, but we can post the unit type this way !

=== Prerequisite ===

sudo apt-get install libjson-perl libfile-slurp-unicode-perl libwww-perl libxml-simple-perl

=== Proposed Crontab entry ===

I propose to run it every 10 minutes

*/10 * * * * /home/pi/cosmodom.pl 2>&1 >> /dev/null

=== Script example ===

cosmodom.pl
<syntaxhighlight lang="perl">
#!/usr/bin/perl
use v5.14;
use LWP::Simple; # From CPAN
use JSON ; # From CPAN
use File::Slurp;
use LWP::UserAgent;
use Crypt::SSLeay;
use Data::Dumper; # Perl core module
use strict; # Good practice
use warnings; # Good practice
use utf8;
use feature qw< unicode_strings >;
my $COSM_API_KEY = '7W0cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx5lyS';
my $COSM_FEED = "xxxxxx";
my $IP=''192.168.0.24";
my $PORT="8080";
my $feed = { 'version' => '1.0.0', 'datastreams' => [] };
# Create an HTTP client
my $ua = LWP::UserAgent->new;
$ua->agent('RaspberryPiDomoticz/1.0 ');
my $trendsurl = "http://$IP:$PORT/json.htm?type=devices&filter=all&used=true&order=Name";
my $json = get( $trendsurl );
die "Could not get $trendsurl!" unless defined $json;
# Decode the entire JSON
my $decoded = JSON->new->utf8(0)->decode( $json );
my @results = @{ $decoded->{'result'} };
foreach my $f ( @results ) {
if ($f->{"SwitchType"}) {
#print $f->{"idx"} . " " . $f->{"Name"} . " " . $f->{"Status"} . "\n";
} elsif ($f->{"Type"} eq "Group") {
#print $f->{"idx"} . " " . $f->{"Name"} . " " . $f->{"Status"} . "\n";
} else {
my $te=$f->{"Data"};
my $name=$f->{"Name"};
next if $te=~/;/;
#next if $f->{"idx"}==3;
my @tab=split(/,/,$te);
foreach my $tem (@tab) {
my ($temp,$unit)=($tem=~/(\d*.?\d*)(.*)/);
$unit=~s/\s*//;
$temp=~s/\s*//;
my $nam;
if ($te=~/,/) { $nam=$name.'_'.$unit; } else {$nam=$name;}
$nam=~s/\s/_/;
$nam=~s/\//_/;
$nam=~s/%/P/;
print "$nam/$temp/$unit\n";
push(@{$feed->{'datastreams'}}, {'id' => $nam, 'current_value' => scalar($temp), 'units' => $unit});
}
}
}
# Create a HTTP request
my $req = HTTP::Request->new(PUT => "https://api.xively.com/v2/feeds/$COSM_FEED");
$req->header('X-ApiKey' => $COSM_API_KEY);
$req->content_type('application/json');
$req->content(encode_json($feed));
# Make the request
my $res = $ua->request($req);
unless ($res->is_success) {
print STDERR $res->status_line, "\n";
print STDERR $res->content, "\n";
}
</syntaxhighlight>

== Sen.Se ==

Using:
SendToSenSe(25.0000,1234);

GetFromSenSe(1234);

=== Prerequisite ===
sudo apt-get install libjson-perl libdatetime-perl libwww-perl

=== script example ===
<syntaxhighlight lang="perl">
use LWP::UserAgent;
use JSON;
use strict;
use warnings;
my $ua = LWP::UserAgent->new;
my $SENSE_API_KEY = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' ;
sub SendToSenSe {
# Get parameters
my $value = $_[0];
# Remove the newline....
chomp $value;
my $feed_id = $_[1];
chomp $feed_id;
my %datalist = ('feed_id' => $feed_id, 'value'=> $value );
my $json = encode_json \%datalist;
#print $json, "\n";
# Create a request
my $req = HTTP::Request->new(POST => "http://api.sen.se/events/?sense_key=".$SENSE_API_KEY);
$req->content_type('application/json');
$req->content($json);
# Pass request to the user agent and get a response back
my $res = $ua->request($req);
# Check the outcome of the response
if ($res->is_success) {
return $res->content, "\n";
}
else {
return $res->status_line, "\n";
}
}
sub GetFromSenSe {
my $feed_id = $_[0];
# Create the request
my $req = HTTP::Request->new(GET => "http://api.sen.se/feeds/$feed_id/last_event/?sense_key=".$SENSE_API_KEY);
$req->content_type('application/json');
#$req->content($json);
# Pass request to the user agent and get a response back
my $res = $ua->request($req);
# Check the outcome of the response
if ($res->is_success) {
return $res->content, "\n";
}
else {
return $res->status_line, "\n";
}
}
</syntaxhighlight>

== GPIO access ==

=== Device::BCM2835 ===

This must be done as root. To change to the root user:

sudo su -

Supports GPIO and SPI interfaces. You must also get and install the bcm2835 library. Details and downloads from http://www.open.com.au/mikem/bcm2835 You must then get and install the Device::BCM2835 perl library from CPAN http://search.cpan.org/~mikem/Device-BCM2835-1.0/lib/Device/BCM2835.pm

use Device::BCM2835;
use strict;
# call set_debug(1) to do a non-destructive test on non-RPi hardware
#Device::BCM2835::set_debug(1);
Device::BCM2835::init()
|| die "Could not init library";
# Blink pin 11:
# Set RPi pin 11 to be an output
Device::BCM2835::gpio_fsel(&Device::BCM2835::RPI_GPIO_P1_11,
&Device::BCM2835::BCM2835_GPIO_FSEL_OUTP);
while (1)
{
# Turn it on
Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 1);
Device::BCM2835::delay(500); # Milliseconds
# Turn it off
Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 0);
Device::BCM2835::delay(500); # Milliseconds
}

Wiring a perl script as a watchdog [http://electrorun.blogspot.fr/2013/06/using-gpio-with-raspberry-pi-and-perl.html}

=== HiPi ===

To download it (as root):
wget http://raspberry.znix.com/hipifiles/hipi-install
perl hipi-install

More details here:
[http://raspberry.znix.com/]

== Reading serial port - Arduino ==

Arduino reports to a ttyUSB* or ttyACM* ata 115200 bauds. The below scripts shown a simple way (tested but work in progress) to read and write to USB port.

=== Prerequisite ===

sudo apt-get install libdevice-serialport-perl libdatetime-perl

=== Writing to serial port ===

Here is a snippet to write to a USB port:

my $msg = "$name;$value1;4;13;M\n";
my $co = $ob->write($msg);
warn "write failed\n" unless ($co);
print "$date W ($co) : $msg \n";
$ob->write_drain;

=== Script (Work in progress) ===
<syntaxhighlight lang="perl">
#!/usr/bin/perl
use warnings;
use strict;
use POSIX qw(strftime);
use Device::SerialPort;
use IO::Handle;
use DateTime;
use Scalar::Util qw(looks_like_number);
my $ccnt;
my $port = '/dev/ttyUSB0';
my $conf = '~/.conf-pasha';
my $ob = Device::SerialPort->new($port, 1) || die "Can't open $port: $ +!";
my $STALL_DEFAULT = 10;
my $timeout = $STALL_DEFAULT;
my $arb = $ob->can_arbitrary_baud;
my $data = $ob->databits(8);
my $baud = $ob->baudrate(115200);
my $parity = $ob->parity("none");
my $hshake = $ob->handshake("rts");
my $stop = $ob->can_stopbits;
my $rs = $ob->is_rs232;
my $total = $ob->can_total_timeout;
$ob->stopbits(1);
$ob->buffers( 4096, 4096 );
$ob->write_settings();
my ($count, $string, $name, $value);
$ob->close || warn "close failed";;
$ob = Device::SerialPort->new($port, 1) || die "Can't open $port: $ +!";
$ob->databits(8);
$ob->baudrate(115200);
$ob->parity("none");
$ob->stopbits(1);
$ob->buffers( 4096, 4096 );
$ob->write_settings();
my $sleep = 5;
print ": write_settings() done\n: sleeping $sleep second to let arduino get ready...\n";
sleep $sleep;
my @vals;
open(FIC,">>log-gw.txt")||die $!;
print FIC "Starting\n";
FIC->autoflush(1);
while(1) {
$ccnt++;
$ob->lastline("\n");

($count, $string) = $ob->read(255);

#print "$ccnt $string\n\n";
@vals = split("\n", $string);
foreach (@vals) {
$_=~ s/\t/\=/;
$_=~ s/\r//;
$_=~ s/\n//;
}
sleep(1);
}
close(FIC);
$ob->write_drain;
$ob->close;
undef $ob;
</syntaxhighlight>
[[Category:Perl]]

Perl for Domoticz - Revision history

Rwaaren: /* Accessing device statuses in Domoticz */