Category Archives: Linux

Yet another Freeboard widget plugin

freeboard-widget-plugins

Two new widget plugins are available for Freeboard.io

  1. Slider widget plugin
  2. Switch widget plugin

Freeboard

A damn-sexy, open source real-time dashboard builder for IOT and other web mashups.

What is It?

Freeboard is a turn-key HTML-based “engine” for dashboards. Besides a nice looking layout engine, it provides a plugin architecture for creating datasources (which fetch data) and widgets (which display data)— freeboard then does all the work to connect the two together. Another feature of freeboard is its ability to run entirely in the browser as a single-page static web app without the need for a server. The feature makes it extremely attractive as a front-end for embedded devices which may have limited ability to serve complex and dynamic web pages.

See it in action @ https://goo.gl/hbAXXU

All plugins are available for download from the following Github repository: https://github.com/onlinux/freeboard-plugins

Slider widget plugin for freeboard.io

slider

 

 

slider-settings

At each value change, a request is sent with the argument pattern %VALUE% replaced with the value set by the slider.

 

Switch widget plugin for freeboard.io

switch

 

switch-settings

Freeboard INSTALLATION

Follow the instructions from Freeboard github site

Freeboard can be run entirely from a local hard drive. Simply download/clone the repository and open index.html. When using Chrome, you may run into issues with CORS when accessing JSON based APIs if you load from your local hard-drive— in this case you can switch to using JSONP or load index.html and run from a local or remote web server.

 

  1. git clone https://github.com/Freeboard/freeboard.git
  2. npm install
  3. grunt

Then run a index.html or index-dev.html through a webserver.

 

PLUGIN INSTALLATION

Copy the plugin file  to your freeboard installation, for example:

$ cp ./slider.js /var/www/freeboard/plugins/

Edit the freeboard index.html file and add a link to the plugin near the end of the head.js script loader, like:

head.js(
  'js/freeboard_plugins.min.js',
  'plugins/slider.js',
  'plugins/switch.js',
  $(function() {
    //DOM Ready
    freeboard.initialize(true);
  })

 

How to control your Domoticz SmartVirtualThermostat (SVT) from your linux desktop or your Raspberry Pi with python and pygame

Smart Virtual Thermostat Plugin for domoticz is provided by Logread 999LV (SVT Domoticz repository : https://github.com/999LV/SmartVirtualThermostat.git ). Many thanks to him!

This utility  will help you to control from internet your domoticz virtual thermostat from a Raspberry Pi equipped with a TFT screen or from any linux PC.

Screenshot_20181229_155406 Screenshot_20181229_155153 Screenshot_20181229_155611

Screenshot_20181229_155515

 

Install libraries:

$ git clone https://github.com/onlinux/thermostat-domoticz.git

run:

$ cd thermostat-domoticz
$ sh setup.sh

Configuration

Modify config.ini

[secret]
server= # Enter your domoticz server name
ip_domoticz=
port= 
username=  # Enter username if exists
password=  # Enter password to access your domoticz server

Start Thermostat Domoticz

$ source venv/bin/activate

Start  linux desktop script:

$ python z.py

Or start  raspberryPi with TFT script

$ python z-pi.py

‘Alt-PageDown’ key or ‘n’ key to roll over the 4 available displays Click to change Meteo Station when displaying forecasts. Meteo Stations are defined within z.py

tlocations = (
				{'code': 'FRXX0099' , 'color': BLACK},
				{'code': 'FRXX4269' , 'color': BLACK},
				{'code': 'FRXX3651' , 'color': BLACK},
				{'code': 'BRXX3505' , 'color': DARKGREEN}
)

Zibase-thermostat

Accéder au thermostat zibase depuis un pc linux ou raspberryPi avec python

Screenshot_20181229_155406

Bien que le futur de notre bonne vieille zibase soit peut être compromis très bientôt, je voulais vous faire partager une application que j’ai développée il y a déjà presque cinq ans (2014), et que je viens de remettre à jour et déposer sur github.

C’est une version wan qui peut-être accédée depuis l’internet ou le réseau local.

Sur le raspberrypi, l’application s’affiche sur un écran TFT tactile dans mon salon. La version RaspberryPi  TFT avec accès aux boutons GPIO n’est pas encore publiée.

La version présentée aujourd’hui et disponible sur le dépot Github , est une version qui tourne sous linux sous environnement X. Tous les commentaires et ‘issues’ sont bienvenues sur github.

Il est peut être possible de l’adapter aux plateformes Windows.

Screenshot_20181229_155515 Screenshot_20181229_155611 Screenshot_20181229_155153

Installation des bibliothèque :

$ git clone https://github.com/onlinux/zibase-thermostat.git
$ cd zibase-thermostat

Installer  python-pip s’il n’est pas déjà installé:

$ sudo apt-get install python-pip

Installation de pywapi

Télécharger la dernière version de la bibliothèque pywapi depuis : <https://launchpad.net/python-weather-api/trunk/0.3.8/+download/pywapi-0.3.8.tar.gz>

Untar les sources et installer :

$ tar xvfz pywapi-0.3.8.tar.gz

$ cd pywapi-0.3.8

$ python setup.py build

$ sudo python setup.py install

$ cd ../zibase-thermostat/

# Installation de la bibliothèque pygame

$ sudo apt-get install python-pygame

Configuration

 

thermostat_variables

Set [global] thermostat variables as specified within zibase interface

Modifier le fichier  config.ini

L’exemple du thermostat zibase ci-dessus devrait donner un fichier config.ini ainsi:

[secret]
 zibaseid = ZiBASE00xxxx
 tokenid  = 00xxxxxx
 [global]
 tempvariable= 28
 setpointdayvariable= 29
 setpointnightvariable= 30
 modevariable= 31
 statevariable= 13
 thermostatscenario= 32

# Lancer Thermostat Zibase

python z.py

Alt-PageDown key to roll over the 4 available displays

Click to change Meteo Station when displaying forecasts.

Meteo Stations are defined within z.py

tlocations = (
				{'code': 'FRXX0099' , 'color': BLACK},
				{'code': 'FRXX4269' , 'color': BLACK},
				{'code': 'FRXX3651' , 'color': BLACK},
				{'code': 'BRXX3505' , 'color': DARKGREEN}
)

Dynamic Highcharts plugin for freeboard.io

Freeboard

A damn-sexy, open source real-time dashboard builder for IOT and other web mashups.

What is It?

Freeboard is a turn-key HTML-based “engine” for dashboards. Besides a nice looking layout engine, it provides a plugin architecture for creating datasources (which fetch data) and widgets (which display data)— freeboard then does all the work to connect the two together. Another feature of freeboard is its ability to run entirely in the browser as a single-page static web app without the need for a server. The feature makes it extremely attractive as a front-end for embedded devices which may have limited ability to serve complex and dynamic web pages.

Dynamic Highcharts widget plugin for freeboard.io

This widget plugin is  based on the highcharts widget plugin created by Hugo Sequeira.

Github repository: https://github.com/onlinux/freeboard-dynamic-highcharts-plugin

See it in action @ https://goo.gl/hbAXXU

dynamic-highcharts-plugin-4

dynamic-highcharts-plugin-1

dynamic-highcharts-plugin-2

INSTALLATION

Copy the file (plugin_highcharts.js from https://github.com/onlinux/freeboard-dynamic-highcharts-plugin) to your freeboard installation, for example:

$ cp ./plugin_highcharts.js /freeboard/plugins/thirdparty

Edit the freeboard index.html file and add a link to the plugin near the end of the head.js script loader, like:

head.js(
  'js/freeboard_plugins.min.js',
  'plugins/thirdparty/plugin_highcharts.js',
  $(function() {
    //DOM Ready
    freeboard.initialize(true);
  })

 

Actuator widget plugin for freeboard.io

Freeboard

A damn-sexy, open source real-time dashboard builder for IOT and other web mashups.

What is It?

Freeboard is a turn-key HTML-based “engine” for dashboards. Besides a nice looking layout engine, it provides a plugin architecture for creating datasources (which fetch data) and widgets (which display data)— freeboard then does all the work to connect the two together. Another feature of freeboard is its ability to run entirely in the browser as a single-page static web app without the need for a server. The feature makes it extremely attractive as a front-end for embedded devices which may have limited ability to serve complex and dynamic web pages.

Actuator widget plugin for freeboard.io

This widget plugin is based on the interactive-indicator created by Stufisher.

See it in action @ https://goo.gl/hbAXXU

Actuator Widget

Actuator Widget

 

Github repository: https://github.com/onlinux/freeboard-plugins

 

I modified it  mainly to fit my needs. It merely links the states ON and OFF to URLs.

actuator-2A click on the indicator switches the state ON/OFF of the actuator which is bound to a http request.

INSTALLATION

Copy the plugin (actuator.js  from https://github.com/onlinux/freeboard-actuator-plugin) to your freeboard installation, for example:

$ cp ./actuator.js /freeboard/plugins/

Edit the freeboard index.html file and add a link to the plugin near the end of the head.js script loader, like:

head.js(
  'js/freeboard_plugins.min.js',
  'plugins/actuator.js',
  $(function() {
    //DOM Ready
    freeboard.initialize(true);
  })

 

Réception 433.92MHz du compteur de consommation électrique OWL Micro+ ou CM180 avec un dongle Realtek RTL2832 DVB.

 

20150127

rtl-sdr dongle + Owl Micro+ CM180

Le programme rtl_433 permet de convertir un dongle RTL2832 initialement prévu pour la réception TV TNT hd en  récepteur 433,92MHz.  Ce dongle est disponible à l’achat sur internet pour une vingtaine d’euros. (Une recherche google sur  “sdr rtl” vous fournira une multitude de renseignements ainsi que des liens sur des boutiques de vente en  ligne proposant ce dongle).

L’acronyme SDR signifie Software Defined Radio, et RTL c’est la puce (RTL2832) qui équipe le dongle .

J’ai acheté le mien chez Passion Radio Shop

Tout nouveau possesseur d’un de ces dongles miraculeux, j’ai ajouté rapidement le support du OWL micro+ au programme rtl_433.  Le projet initial rtl_433 peut être téléchargé ici: https://github.com/merbanan/rtl_433 (depuis février 2015 mes modifications y ont été intégrées. Désormais le programme rtl_433 reconnaît  les trames envoyées par OWL CMR180)

Je l’ai adapté afin de supporter le transmetteur OWL CMR180 qui accompagne le récepteur OWL CM180. Vous pouvez télécharger un fichier zip disponible  sur le repository github https://github.com/onlinux/rtl_433 ou bien cloner le projet en local sur votre pc

git clone https://github.com/onlinux/rtl_433.git
cd rtl_433/
mkdir build
cd build
cmake ../
make
make install

20150127-zoom

@I7:~/rtl_433/build$ rtl_433 
Registering protocol[01] Rubicson Temperature Sensor 
Registering protocol[02] Prologue Temperature Sensor 
Registering protocol[03] Silvercrest Remote Control 
Registering protocol[04] ELV EM 1000 
Registering protocol[05] ELV WS 2000 
Registering protocol[06] Waveman Switch Transmitter 
Registering protocol[07] Steffen Switch Transmitter
Registering protocol[08] Acurite 5n1 Weather Station
Registering protocol[09] Acurite Temperature and Humidity Sensor
Registering protocol[10] Acurite 896 Rain Gauge
Registering protocol[11] LaCrosse TX Temperature / Humidity Sensor
Registering protocol[12] Oregon Scientific Weather Sensor
Registering protocol[13] KlikAanKlikUit Wireless Switch
Registering protocol[14] AlectoV1 Weather Sensor
Registering protocol[15] Intertechno 433
Registering protocol[16] Mebus 433
Max number of protocols reached 15
Found 1 device(s):
 0: Generic, RTL2832U, SN: 77771111153705777
Using device 0: Generic RTL2832U
Found Rafael Micro R820T tuner
Exact sample rate is: 250000.000414 Hz
Sample rate set to 250000.
Sample rate decimation set to 0. 250000->250000
Bit detection level set to 10000.
Tuner gain set to Auto.
Reading samples in async mode...
Tuned to 433920000 Hz.

Energy Sensor CMR180 Id 6280 power: 240W, total: 508308384W, Total Energy: 141.196kWh
Weather Sensor THGR122N RC 86 Channel 1 Temp: 19.5°C 67.1°F Humidity: 46%
Energy Sensor cmr180 Id 6282 power: 272W
Sensor temperature event:
protocol = Rubicson/Auriol, 36 bits
rid = 1d
temp = 7.5
1d 80 4b f0 00 
Energy Sensor CMR180 Id 6280 power: 272W, total: 508323744W, Total Energy: 141.201kWh

Pour la réception à l’aide d’un arduino ou d’un raspberry pi, se reporter à mon post précédent https://blog.onlinux.fr/decode-and-parse-the-oregon-scientific-v3-radio-data-transmitted-by-owl-cm180-energy-sensor-433-92mhz-2/.

Decode and parse the Oregon Scientific V3 radio data transmitted by OWL CM180 Energy sensor (433.92MHz)

Owl micro+ Wireless electricity monitor runs on Oregon Scientific V3 protocol.

After buying one of those wonderful little devices to study the energy consumed at home, i browsed the internet to find a way to decode frames sent by the transmitter (CMR180) but I have not found any application describing the coding system of the data within  the radio frames. So I decided to study the radio packets to decode the system.

20150117_142540

Please visit the Github repository (https://github.com/onlinux/OWL-CMR180) to get all information about how to decode the packets.

Code available for RaspberryPi and Arduino.

Load arduino sketch to run a mini Owl Micro+ energy monitor as shown on the picture above.(https://raw.github.com/onlinux/OWLCMR180/master/arduino/oregon_owl.ino)

 

 

Monter une partition d’un fichier .img sur un périphérique de rebouclage

eric@I7:~/raspi-bck$ fdisk -u -l raspidev.img 

Disque raspidev.img : 7892 Mo, 7892631552 octets
255 têtes, 63 secteurs/piste, 959 cylindres, total 15415296 secteurs
Unités = secteurs de 1 * 512 = 512 octets
Taille de secteur (logique / physique) : 512 octets / 512 octets
taille d'E/S (minimale / optimale) : 512 octets / 512 octets
Identifiant de disque : 0x000b5098

Périphérique Amorçage Début       Fin   Blocs Id. Système
raspidev.img1          8192    122879   57344  c  W95 FAT32 (LBA)
raspidev.img2        122880  15415295 7646208 83  Linux

Prendre le numéro du premier secteur de la partition qui nous intéresse et multiplier ce nombre par la taille d’un secteur (ici 512 octets). Si l’on veut monter la deuxième partition, par exemple, on obtiendra 122880 * 512 = 69914560

Maintenant créer un répertoire et y monter la partition:

mkdir /tmp/raspidev
sudo mount -o loop,offset=62914560 raspidev.img /tmp/raspidev/

Une fois terminer , démonter la partion :

sudo umount /tmp/raspidev/
rm -r /tmp/raspidev/

Détecteur de mouvement (PIR) du Raspberry Pi intégré à la ZiBASE – Part 2/2

Nous avons vu dans la partie 1, comment installer le module PIR,  lancer le script python pir.py et déclarer un périphérique virtuel sur la ZiBASE.

zibase

Nous allons voir maintenant comment déclarer notre script python comme un service linux qui sera démarré automatiquement à chaque reboot du Raspberry Pi.

Les fichiers nécessaires

Rappel: Les fichiers sont disponibles au téléchargement sur le site https://github.com/onlinux/Raspberry-Pi-PIR .Vous pourrez y télécharger l’ensemble du projet:

pi@raspi $ wget https://github.com/onlinux/Raspberry-Pi-PIR/archive/master.zip
pi@raspi ~ $ unzip master.zip 

ll-RAspberryLe fichier qui va nous permettre de déclarer notre script  python  comme service système est le fichier pir.

Il faut dans un premier temps copier ce fichier dans le répertoire /etc/init.d du Raspberry Pi et lui changer ses droits:

sudo cp pir /etc/init.d
sudo chmod 755 /etc/init.d

Copier le script python dans le répertoire /usr/local/bin

sudo cp pir.py /usr/local/bin
sudo chmod 755 /usr/local/bin/pir.py

Vous pouvez dès à présent exécuter  le script pour lancer le service :

sudo /etc/init.d/pir restart

execution-pir

Pour que le service soit exécuté à chaque reboot du Raspberry Pi, tapez:

sudo update-rc.d pir defaults

update-rc1

 

A ce stade, vous pouvez rebooter le Raspberry Pi, notre service sera lancé à chaque démarrage.

Le script pir

#! /bin/sh                                                                                                    
#                                                                                                                 
# Author: Eric Vandecasteele, 2014                                                                                
# https://blog.onlinux.fr                                                                                              
#                                                                                                                            
# /etc/init.d/pir                                                                                                            
#                                                                                                                                
### BEGIN INIT INFO                                                                                                                  
# Provides:          pir                                                                                                              
# Required-Start:                                                                                                                       
# Required-Stop:                                                                                                                           
# Default-Start:     2 3 4 5                                                                                                                
# Default-Stop:      0 1 6                                                                                                                   
# Short-Description: pir daemon drives the Passive Infra Red Motion Detector
# Description:       The pir daemon sends a http request on any Motion Detection Alarm
### END INIT INFO

# This next line determines what user the script runs as.
# Root generally not recommended but necessary if you are using the Raspberry Pi GPIO from Python.
DAEMON_USER=root

PATH=/bin:/usr/bin:/sbin:/usr/sbin
DAEMON=/usr/local/bin/pir.py

# The process ID of the script when it runs is stored here:
PIDFILE=/var/run/pir.pid

NAME=pir

test -x $DAEMON_OPTS || exit 0

. /lib/lsb/init-functions


do_start()
{
        # Return
        #   0 if daemon has been started
        #   1 if daemon was already running
        #   2 if daemon could not be started

        if pidofproc -p $PIDFILE "$DAEMON" > /dev/null 2>&1 ; then
                return 1
        fi
}

case "$1" in
  start)
     log_daemon_msg "Starting $NAME"
     do_start
     RET_STATUS=$?
     case "$RET_STATUS" in
        1)
           log_success_msg
           [ "$VERBOSE" != no ] && [ $RET_STATUS = 1 ] && log_warning_msg "Daemon was already running"
        ;;
        *)
           start-stop-daemon --start  --background --oknodo --pidfile $PIDFILE --make-pidfile --user $DAEMON_USER --chuid $DAEMON_USER --exec $DAEMON  $DAEMON_OPTS 
           log_end_msg $?
        ;;
     esac
     ;;
  stop)
     log_daemon_msg "Stopping $NAME"
     start-stop-daemon --stop --pidfile $PIDFILE --retry 10
     log_end_msg $?
   ;;
  force-reload|restart)
     $0 stop
     $0 start
   ;;
  status)
     status_of_proc -p $PIDFILE $DAEMON $NAME  && exit 0 || exit $?
   ;;
 *)
   echo "Usage: /etc/init.d/pir {start|stop|restart|force-reload|status}"
   exit 1
  ;;
esac
exit 0

Le fichier log

Dans la partie 1, nous avons vu que dans le script pir.py nous avons défini notre fichier log comme /var/log/pir.log
pir-log

Copier le fichier  de configuration de la log logrotate.d/pir dans le répertoire /etc/logrotate.d

sudo cp logrotate.d/pir /etc/logrotate.d
/var/log/pir.log {
        daily
        missingok
        rotate 7
        compress
        delaycompress
        notifempty
        create 640 root adm
        sharedscripts
        postrotate
                /etc/init.d/pir restart > /dev/null
        endscript
}

La gestion de la logfile de notre service pir sera désormais prise en charge par le système.

Voilà, à ce stade le projet est terminé. Nous avons installé un service sur notre Raspberry Pi qui à chaque détection de mouvement va envoyer une requête http à la ZiBASE, afin d’alimenter notre détecteur de présence virtuel.pi-motion-plate-forme

Détecteur de mouvement (PIR) du Raspberry Pi intégré à la ZiBASE – Part 1/2

Dans cet article, je vais vous montrer comment intégrer, comme périphérique virtuel sur la ZiBASE, un détecteur de mouvement connecté à un Raspberry Pi. Nous allons voir l’ensemble des étapes , depuis la connexion du détecteur (PIR) au RaspBerry Pi , la création du script python , la gestion du service pir et le scénario sur la ZiBASE qui va nous permettre d’alimenter un détecteur virtuel, qui pourra ensuite être intégré à une alarme Zibase ou être utilisé dans d’autres scénarios.zibasepi-motion-plate-forme

Pour l’installation du module, j’ai suivi l’excellent article en anglais de Matt Hawkins intitulé  Cheap PIR Sensors and the Raspberry Pi – Part 1 dont je reprends les grandes lignes pour montrer comment brancher et faire fonctionner ce merveilleux petit module.

Le matériel nécessairepir

Nous allons utiliser comme détecteur un module PIR 5V (Passive Infra Red) que l’on trouvera facilement dans une boutique en ligne pour quelques euros. Je l’ai personnellement trouvé pour $2.40 chez www.dx.com. Nous allons le  connecter à un Raspberry Pi  (dans mon cas, j’utilise un Raspberry Pi B+ qui tourne sous Linux Raspbian version Wheezy du 20/06/2014)

Branchement du module PIR20140916_173043

Voici un schéma représentant les trois sorties du module et leurs branchements sur les pattes GPIO sur Raspberry Pi. Le module a deux potentiomètres qui permettent d’ajuster ses performances. Un pour la sensibilité (Sx) et le second (Tx) pour le réglage du temps où la sortie (pin OUT) du module reste à 3V lors de la détection d’un mouvement.

PIR Module

Module PIR

20140916_173058

Paquets requis pour la gestion GPIO du Raspberry Pi

Pour la bonne éxécution du script python, il est nécessaire auparavant d’installer les différents paquets suivants:

sudo apt-get install python-dev
sudo apt-get install python-rpi.gpio
sudo apt-get install python-requests

Le script Python

J’ai repris le script donné en exemple par Matt, et l’ai adapté afin qu’il puisse tourner comme daemon linux et qu’il envoie une requête http à la ZiBASE lors de la détection de mouvement.

Les fichiers sont disponibles au téléchargement sur le site https://github.com/onlinux/Raspberry-Pi-PIR. Vous pourrez y télécharger l’ensemble du projet:

pi@raspi $ wget https://github.com/onlinux/Raspberry-Pi-PIR/archive/master.zip 

pi@raspi ~ $ unzip master.zip 
Archive: master.zip
b2cffd544e4ca4ec420723e08b7fb15508b8d83c
 creating: Raspberry-Pi-PIR-master/
 extracting: Raspberry-Pi-PIR-master/README.md 
 creating: Raspberry-Pi-PIR-master/logrotate.d/
 inflating: Raspberry-Pi-PIR-master/logrotate.d/pir 
 inflating: Raspberry-Pi-PIR-master/pir 
 inflating: Raspberry-Pi-PIR-master/pir.py 
pi@raspi ~ $
#!/usr/bin/python
#
# pir.py
#

# Import required Python libraries
import time
import RPi.GPIO as GPIO
import requests
import logging
import signal
import sys
import threading


URL_ZIBASE = 'http://192.168.0.100/cgi-bin/domo.cgi?CMD=LM%2049'
MOTION_ALARM_DELAY =  60

logging.basicConfig(format='%(asctime)s %(levelname)s:%(message)s', filename='/var/log/pir.log',level=logging.DEBUG)

def handler(signum = None, frame = None):
    logging.debug (' Signal handler called with signal '+ str(signum) )
    time.sleep(1)  #here check if process is done
    logging.debug( ' Wait done')
    sys.exit(0)   
    
for sig in [signal.SIGTERM, signal.SIGINT, signal.SIGHUP, signal.SIGQUIT]:
    signal.signal(sig, handler)

# Each request  gets its own thread
class RequestThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        try:
           result = requests.get(url = URL_ZIBASE)
           logging.debug(" %s -> %s" % (threading.current_thread(), result))
        except requests.ConnectionError, e:
           logging.warning(' %s CONNECTION ERROR %s' % (threading.current_thread(), e) )
        
        
# Use BCM GPIO references
# instead of physical pin numbers
GPIO.setmode(GPIO.BCM)

# Define GPIO to use on Pi
GPIO_PIR = 7

logging.info( "PIR Module Holding Time Test (CTRL-C to exit)")

# Set pin as input
GPIO.setup(GPIO_PIR,GPIO.IN)

Current_State  = 0
Previous_State = 0

try:

  logging.info('Waiting for PIR to settle ...')

  # Loop until PIR output is 0
  while GPIO.input(GPIO_PIR)==1:
    Current_State  = 0

  logging.info('  Ready')

  # Loop until users quits with CTRL-C
  while True :

    # Read PIR state
    Current_State = GPIO.input(GPIO_PIR)

    if Current_State==1 and Previous_State==0:
      # PIR is triggered
      start_time=time.time()
      logging.info(' Motion detected!')
      # Record previous state
      Previous_State=1
      RequestThread().start()
      
    elif Current_State==0 and Previous_State==1:
      # PIR has returned to ready state
      stop_time=time.time()
      elapsed_time=int(stop_time-start_time)
      logging.info(" (Elapsed time : " + str(elapsed_time) + " secs)")
      Previous_State=0
      logging.info(' Going to sleep for %s seconds' % (MOTION_ALARM_DELAY))
      time.sleep(MOTION_ALARM_DELAY)
      logging.info('  Ready')
      
    time.sleep(1)	
    
finally:
	logging.info( "  Reset GPIO settings & Quit")
	# Reset GPIO settings
	GPIO.cleanup()

Le script dans les détails

Définition de la requête http vers la ZiBASE

URL_ZIBASE = 'http://192.168.0.100/cgi-bin/domo.cgi?CMD=LM%2049'

Nous définissons ici la requête http qui va être envoyée vers la zibase. Ma zibase a pour adresse IP sur mon réseau local (lan) 192.168.0.100. Il faudra bien sûr changer cette adresse et l’adapter à votre installation. Ensuite le paramètre CMD=LM 49 signifie ‘lancer l’exécution du scénario numéro 49’. Nous reviendrons plus tard sur cette notion de numéro de scénario lorsque nous aborderons la conception du scénario sur notre zibase.

 Durée de latence entre deux détections ou MOTION_ALARM_DELAY

MOTION_ALARM_DELAY =  60

Je définis ici, la durée en secondes ou le détecteur ignorera la détection de nouveaux mouvements. Une minute par défaut. En fait cela permet surtout de soulager la taille de la log. Ici, il n’y a pas de notion de durée de vie de la batterie comme dans les détecteurs classiques autonomes, donc si on le souhaite on peut très bien définir ce paramètre égale à 1 mais je n’en vois vraiment pas l’intérêt.

Configuration de la log

logging.basicConfig(format='%(asctime)s %(levelname)s:%(message)s', filename='/var/log/pir.log',level=logging.DEBUG)

Nous définissons ici le nom du fichier log du daemon (/var/log/pir.log) ou tous les messages seront inscrits avec pour niveau d’information ‘DEBUG’.
Nous verrons plus tard, comment définir une entrée dans logrotate.d qui permet d’avoir une gestion des fichiers log automatisée.

Gestion des signaux envoyés au daemon

def handler(signum = None, frame = None):
    logging.debug (' Signal handler called with signal '+ str(signum) )
    time.sleep(1)  #here check if process is done
    logging.debug( ' Wait done')
    sys.exit(0) 

for sig in [signal.SIGTERM, signal.SIGINT, signal.SIGHUP, signal.SIGQUIT]:
    signal.signal(sig, handler)


finally:
	logging.info( "  Reset GPIO settings & Quit")
	# Reset GPIO settings
	GPIO.cleanup()

Les signaux de terminaison de processus sont interceptés, ce qui permet à notre script de se terminer gracieusement et surtout de laisser une situation propre au niveau de la gestion des GPIO  du Raspberry Pi ( appel à la commande  GPIO.cleanup())

Notion de Thread

# Each request  gets its own thread
class RequestThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        try:
           result = requests.get(url = URL_ZIBASE)
           logging.debug(" %s -> %s" % (threading.current_thread(), result))
        except requests.ConnectionError, e:
           logging.warning(' %s CONNECTION ERROR %s' % (threading.current_thread(), e) )

Nous allons lancer la requête http vers la Zibase dans un thread, ce qui permet à notre script de ne pas être bloquant lors d’un problème de connexion à la zibase (problème réseau ou zibase déconnectée). Il m’est arrivé de voir la connexion refusée par la zibase, peut être était-ce lors du reboot après enregistrement d’un nouveau périphérique. Si la requête n’était pas exécutée dans un thread, lors d’un problème de connexion, le daemon serait tué!

Boucle de gestion de la détection de mouvement

# Use BCM GPIO references
# instead of physical pin numbers
GPIO.setmode(GPIO.BCM)

# Define GPIO to use on Pi
GPIO_PIR = 7

logging.info( "PIR Module Holding Time Test (CTRL-C to exit)")

# Set pin as input
GPIO.setup(GPIO_PIR,GPIO.IN)

Current_State  = 0
Previous_State = 0

try:

  logging.info('Waiting for PIR to settle ...')

  # Loop until PIR output is 0
  while GPIO.input(GPIO_PIR)==1:
    Current_State  = 0

  logging.info('  Ready')

  # Loop until users quits with CTRL-C
  while True :

    # Read PIR state
    Current_State = GPIO.input(GPIO_PIR)

    if Current_State==1 and Previous_State==0:
      # PIR is triggered
      start_time=time.time()
      logging.info(' Motion detected!')
      # Record previous state
      Previous_State=1
      RequestThread().start()
      
    elif Current_State==0 and Previous_State==1:
      # PIR has returned to ready state
      stop_time=time.time()
      elapsed_time=int(stop_time-start_time)
      logging.info(" (Elapsed time : " + str(elapsed_time) + " secs)")
      Previous_State=0
      logging.info(' Going to sleep for %s seconds' % (MOTION_ALARM_DELAY))
      time.sleep(MOTION_ALARM_DELAY)
      logging.info('  Ready')
      
    time.sleep(1)	

Test du script

A ce stade le script est fonctionnel. Pour tester son fonctionnement, il faut lancer le script sous root (sudo) et visualiser la log dans un autre terminal.
Si vous bougez devant votre détecteur de mouvement vous verrez la log réagir.

sudo_pir

tailf pir_log

Si vous tapez CTRL-C dans la fenêtre de lancement du script, dans la log, vous verrez que le signal a été intercepté et a permis au script de terminer proprement en envoyant son ordre GPIO.clean().

tailf pir_log1

 

Elaboration du scénario sur la ZiBASE

Avant de créer un scénario, il faut créer un détecteur virtuel pour qu’il puisse remonter les alertes de notre module PIR connecté au Raspberry PI.

Création du détecteur virtuel

creation_device

Nous devons créer un périphérique virtuel de catégorie détecteurs, type MS13 par exemple (détecteur de mouvement) .  Indiquez le nom de votre choix ( pour moi ce sera PI-MOTION) et lui attribuer un identifiant radio. Cet identifiant radio fictif doit être sous la forme “CS suivi de 9 chiffres'” ex: CS123456789,  pour ma part j’ai choisi CS123456787 car j’ai déjà 2 périphériques virtuels créés ( ouverture  fenêtre et détecteur de présence pour mon PSM02 Philio) ensuite  cliquez sur « Capture d’identifiant » puis  enfin, cliquez sur « Sauvegarder » après avoir coché, bien sûr, la case « Visualiser sur les interfaces  de l’utilisateur».

Nous avons à ce stade créer notre détecteur de présence virtuel. Nous devons maintenant l’alimenter et pour cela nous allons créer un scénario.

Création du scénario

scenario

 

Créez un nouveau scénario, donnez lui un nom ( pour moi ce sera PIR-MOTION-49) . Le nombre 49 correspond au numéro du scénario nouvellement créé. Pour connaître ce numéro qui nous  est nécessaire lors de la requête http dans notre script python, une fois le scénario créé, cliquez sur le bouton “Tester le scénario”, vous verrez ensuite dans le suivi d’activité le déclenchement  du scénario avec son numéro associé (pour moi c’est 49)  entre parenthèses.numero scenario

 

Une fois le numéro du scénario connu , nous pouvons construire l’url qui permettra à notre script pir.py de déclencher le scénario sur la ZiBASE.

Souvenez-vous, ligne 16 du script:

URL_ZIBASE = 'http://192.168.0.100/cgi-bin/domo.cgi?CMD=LM%2049'

Modifiez le numéro dans le fichier pir.py  LM%20XX , avec pour XX= votre numéro de script.

Une fois cette étape effectuée, si vous exécutez le script sur le raspberry Pi, celui-ci doit déclencher le scénario sur la ZiBASE qui va alimenter notre détecteur virtuel, et nous pouvons visualiser sur l’interface le déclenchement d’une alerte, si vous bougez devant votre module PIR, bien sûr!

 

pi-motion-plate-forme

Création du service pir

Dans l’article qui suivra PART 2, nous allons voir comment déclarer notre script pir.py comme un service linux, et le paramètrer pour qu’il s’exécute automatiquement au reboot du Raspberry Pi, et aussi paramétrer la gestion de la log avec logrotate.