Author Archives: admin

ATTINY85 – INTERRUPTS AND WDT CODE

I use that code as a basis for all my sensor sketch developments with a Attiny85 chip.
It might be useful for some geeks out there.

Attiny85

Attiny85

Actually, this page is a kind of reminder and a startup for all my new projects.
It’s based on the use of watch dog timers and interrupts which is a very easy way to code sensors (temperature, humidity, shock, etc) and very efficient for not wasting to much power for the circuit. A Attiny85 should draw only a few micro amps(µA) while sleeping.

//
//                  +-\/-+
// Ain0 (D 5) PB5  1|    |8  Vcc
// Ain3 (D 3) PB3  2|    |7  PB2 (D 2) Ain1
// Ain2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1
//            GND  4|    |5  PB0 (D 0) pwm0
//                  +----+

#include 
#include 
#include  


#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
// https://www.arduino.cc/en/Reference/Volatile
// volatile keyword:
// Specifically, it directs the compiler to load the variable from RAM and not from a storage register,
// which is a temporary memory location where program variables are stored and manipulated. 
// Under certain conditions, the value for a variable stored in registers can be inaccurate.

volatile boolean f_wdt = 1;

// Use pin PB0 as wake up pin
const int wakeUpPin = 0;

const byte pinLed = 4;
const byte pinLedRed = 3;
  
void blink(int ii) {
  pinMode(pinLed, OUTPUT);
  for (byte i = ii ;  i > 0 ; i--){
     digitalWrite(pinLed, HIGH);
     delay(50);
     digitalWrite(pinLed, LOW); 
     delay(50);
  }
  
  pinMode(pinLed, INPUT); // reduce power
}

void blinkRed(int ii) {
  pinMode(pinLedRed, OUTPUT);
  for (byte i = ii ;  i > 0 ; i--){
     digitalWrite(pinLedRed, HIGH);
     delay(50);
     digitalWrite(pinLedRed, LOW); 
     delay(50);
  }
  pinMode(pinLedRed, INPUT); // reduce power
}

/******************************************************************/
// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec
void setup_watchdog(int ii) {

  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<wdce); ww="bb;" mcusr="" &="~(1<<WDRF);" start="" timed="" sequence="" wdtcr="" |="(1<<WDCE)" (1<<wde);="" set="" new="" watchdog="" timeout="" value="" }="" void="" system_sleep()="" {="" cbi(adcsra,aden);="" switch="" analog="" to="" digitalconverter="" off="" set_sleep_mode(sleep_mode_pwr_down);="" sleep="" mode="" is="" here="" sleep_enable();="" sleep_mode();="" system="" sleeps="" here,="" waiting="" for="" interrupt="" sleep_disable();="" continues="" execution="" when="" out="" sbi(adcsra,aden);="" on="" service="" executed="" isr(wdt_vect)="" f_wdt="1;" global="" flag="" setup()="" setup_watchdog(9);="" pinmode(wakeuppin,="" input);="" the="" pin="" input="" digitalwrite(wakeuppin,="" high);="" activate="" internal="" pullup="" resistor="" pcmsk="" (pcint0);="" change="" mask="" register="" gifr="" (pcif);="" clear="" any="" outstanding="" interrupts="" general="" gimsk="" (pcie);="" enable="" sei();="" isr="" (pcint0_vect){}="" loop()="" system_sleep();="" if="" (=""> 0) {  // watchdog signal
    blink(5);
    f_wdt=0;         //reset flag
  } else {
    blinkRed(5);     // PCINT0 occured
  }
    
}
</wdce);>

Low battery detection code

Nick Gammon http://www.gammon.com.au/power

uint16_t readVcc(void) {
  uint16_t result;
  // Read 1.1V reference against Vcc
  ADMUX = (0<<REFS0) | (12<<MUX0);
  delay(2); // Wait for Vref to settle
  ADCSRA |= (1<<ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCW;
  return 1018500L / result; // Back-calculate AVcc in mV
}

Détecteur de choc & TX 433Mhz pilotés avec le Microcontrôleur AVR ATTINY85

Circuit monté sur breadboard

Circuit monté sur breadboard

Avec la mise en veille (SLEEP_MODE_PWR_DOWN) et l’utilisation des interruptions , le circuit au repos ne consomme que 4µA avec un microcontrôleur Attiny85 (1€89 sur ebay) . J’alimente le circuit avec une pile bouton CR2032 3V achetée chez Ikea par lot de 8 pour quelques €uros. Le circuit devrait tourner beaucoup plus d’une année. 20160122_104647

300px-KY002

Détecteur de choc

A chaque détection de choc, le transmetteur 433Mhz émet un signal RF qui est reconnu par une Zibase en périphérique E10. Ce signal RF est défini dans le code de l’Attiny85 à la ligne n°46 (mySwitch.switchOn(‘e’, 3,2); // Test Zibase signal id E10) Dans mon circuit, je n’alimente pas le détecteur  en 5V, mais je l’utilise comme simple contacteur qui déclenche une interruption lorsqu’il y a détection de choc ( voir code: digitalWrite(WAKEUP_PIN, HIGH); // Activate internal pullup resistor ).

sku_334387_1
Tx 433MHz

Le détecteur,  grâce à la zibase, est intégré au système d’alarme . Présentement, il m’est inutile de monter une antenne de 17,3cm. En effet le signal est suffisamment puissant pour être reçu 5/5 à environ 7 mètres du récepteur RF ( la zibase, ou mon stick RTL-SDR connecté à un Raspberry Pi).

Détection niveau batterie faible

Un niveau de batterie faible est indiqué par la led qui flashe toutes les 8 secondes. Pour la détection de niveau de batterie faible, je me suis inspiré du post de Nick Gammon http://www.gammon.com.au/power

uint16_t readVcc(void) {
  uint16_t result;
  // Read 1.1V reference against Vcc
  ADMUX = (0<<REFS0) | (12<<MUX0);
  delay(2); // Wait for Vref to settle
  ADCSRA |= (1<<ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCW;
  return 1018500L / result; // Back-calculate AVcc in mV
}

Consommation du circuit avec un Arduino et Attiny85

sku_334387_1

TX 433.92MHz

  1. Attiny85: 4µA 
  2. Avec un arduino Nano : 43mA !!!
  3. Arduino M.J duino uno: 6,5mA
  4. Arduino XDRduino: 25mA
  5. Arduino Mini Pro: 3,5 mA . En ôtant la LED (on) et le régulateur de tension 5V, on pourrait tomber à moins d’1mA

RF Shock sensor Sketch_bb

Le script pour Attiny85

Pour programmer l’Attiny85 à l’aide d’un arduino, je me suis inspiré du post d’Erwan http://labalec.fr/erwan/?p=1508. Éventuellement, ne pas oublier de graver la séquence d’initialisation (bootloader) de l’Attiny85.

// https://blog.onlinux.fr/
//
//
//                           +-\/-+
//          Ain0 (D 5) PB5  1|    |8  Vcc
//          Ain3 (D 3) PB3  2|    |7  PB2 (D 2) Ain1 -
// LED +pin Ain2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1 - Shock sensor pin
//                     GND  4|    |5  PB0 (D 0) pwm0 - RF433 tx pin
// 
// **** INCLUDES *****
#include <avr/sleep.h>
#include <avr/wdt.h>
#include <RCSwitch.h>

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define LOW_BATTERY_LEVEL 2500 //mV. Led will flash if battery level is lower than this value
#define WDT_COUNT  225  // wdt is set to 8s, 8x225=1800 seconds = 30 minutes

volatile boolean f_wdt = 0;
volatile byte count = WDT_COUNT;
volatile boolean f_int = 0;
volatile boolean lowBattery = 0;
volatile boolean switchState = HIGH;

const byte TX_PIN   = PB0;  // Pin number for the 433mhz OOK transmitter
const byte LED_PIN  = PB4;
const byte WAKEUP_PIN = PB1;  // Use pin 1 as wake up pin

RCSwitch mySwitch = RCSwitch();

/******************************************************************/
 
void setup()
{
  setup_watchdog(9);
  pinMode(TX_PIN, OUTPUT);
  pinMode(WAKEUP_PIN, INPUT);        // Set the pin to input
  digitalWrite(WAKEUP_PIN, HIGH);    // Activate internal pullup resistor  
  mySwitch.enableTransmit(TX_PIN);
  
  mySwitch.switchOn('e', 3,2);      // Test Zibase signal id E10
  
  lowBattery =  !(readVcc() >= LOW_BATTERY_LEVEL); // Initialize battery level value
  
  PCMSK  |= bit (PCINT1);  // set pin change interrupt PB1
  GIFR   |= bit (PCIF);    // clear any outstanding interrupts
  GIMSK  |= bit (PCIE);    // enable pin change interrupts  
  sei();         
}


// set system into the sleep state 
// system wakes up when watchdog is timed out
void system_sleep() {
  cbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter OFF

  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_enable();

  sleep_mode();                        // System sleeps here

  sleep_disable();                     // System continues execution here when watchdog timed out 
  sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
}

// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9=8sec
void setup_watchdog(int ii) {

  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<WDCE);
  ww=bb;

  MCUSR &= ~(1<<WDRF);
  // start timed sequence
  WDTCR |= (1<<WDCE) | (1<<WDE);   
  // set new watchdog timeout value   
  WDTCR = bb;   WDTCR |= _BV(WDIE); 
}
    
// Watchdog Interrupt Service / is executed when watchdog timed out 
ISR(WDT_vect) {   
  if (count >= WDT_COUNT) {
   f_wdt=true;  // set WDTl flag
   count=0;
  }
  count++;
} 

ISR (PCINT0_vect){
  f_int=true; // set INT flag
}
 
void loop()
{
  system_sleep();
  
  if (lowBattery)        // lowBattery is at setup().
    lowBatteryWarning(); // Flash for 1ms every 8s http://www.gammon.com.au/power
  
  
  if (f_int) {
    blink(2);
    cli();
    mySwitch.switchOn('e', 3,2);      // Zibase signal id E10
    f_int=false;  // Reset INT Flag
    sei();
  } 
  else if ( f_wdt ) {
    blink(5);
    cli(); // disable interrupts
    lowBattery = !(readVcc() >= LOW_BATTERY_LEVEL);
    f_wdt=false; // reset WDT Flag
    sei(); // enable interrupts
  }
    
}


void blink(int ii) {
  pinMode(LED_PIN, OUTPUT);
  for (byte i = ii ;  i > 0 ; i--){
     digitalWrite(LED_PIN, HIGH);
     delay(50);
     digitalWrite(LED_PIN, LOW); 
     delay(50);
  }
  
  pinMode(LED_PIN, INPUT); // reduce power
}

void lowBatteryWarning () {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite (LED_PIN, HIGH);  
  delay (1);       // mS        
  digitalWrite (LED_PIN, LOW);    
  //delay (999); 
  pinMode(LED_PIN, INPUT); // reduce power  
}

uint16_t readVcc(void) {
  uint16_t result;
  // Read 1.1V reference against Vcc
  ADMUX = (0<<REFS0) | (12<<MUX0);
  delay(2); // Wait for Vref to settle
  ADCSRA |= (1<<ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCW;
  return 1018500L / result; // Back-calculate AVcc in mV
}

Et la suite…

Le circuit pourrait ếtre encore plus miniaturisé en se passant du breadboard.
Maintenant il ne reste qu’à trouver un joli boîtier pour cacher toute l’électronique.
Malheureusement je n’ai pas d’imprimante 3D!

20160122_121130_cut

Le détecteur de choc et en haut le détecteur d’ouverture

Si vous avez des idées pour une solution esthétique, n’hésitez pas!

Détecteur de mouvement PIR & TX 433Mhz pilotés avec le Microcontrôleur AVR ATTINY85

PIR Atinny85 Sketch_bb

 

pir

Détecteur de mouvement PIR

Avec la mise en veille (SLEEP_MODE_PWR_DOWN) et l’utilisation des interruptions (INT0) , le circuit au repos ne consomme que 30µA avec un Attiny85 (1€89 sur ebay) . Avec le jeu de piles AAA ( en fait je n’en ai

Attiny85

Attiny85

mis que 3 en série), le circuit devrait tourner plus d’une année.

A chaque détection de mouvement, le transmetteur 433Mhz envoie une trame qui est reconnue par une Zibase en périphérique B15.

Le détecteur,  grâce à la zibase, est intégré au système d’alarme et,  avec  un scénario, il permet de gérer la lumière de la cuisine.

Consommation avec un Arduino

sku_334387_1

TX 433.92MHz

  1. Avec un arduino Nano : 43mA !!!
  2. Arduino M.J duino uno: 6,5mA
  3. Arduino XDRduino: 25mA
  4. Arduino Mini Pro: 3,5 mA . En ôtant la LED (on) et le régulateur de tension 5V, on pourrait tomber à moins d’1mA, mais ce sera toujours bien plus qu’un circuit à base de l’Attiny85. Il faudra que j’essaie!

Le script pour Attiny85

Pour programmer l’Attiny85 à l’aide d’un arduino, je me suis inspiré du post d’Erwan http://labalec.fr/erwan/?p=1508. Éventuellement, ne pas oublier de graver la séquence d’initialisation (bootloader) de l’Attiny85.

// **** INCLUDES *****
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include  

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif


// Use pin 0 as wake up pin
const int wakeUpPin = 0;
volatile int ledState = LOW;
#define tx 1 // Pin number for the 433mhz OOK transmitter
#define pinLed 4
RCSwitch mySwitch = RCSwitch();

// set system into the sleep state 
void system_sleep() {
 cbi(ADCSRA,ADEN); // switch Analog to Digitalconverter OFF
 set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
 sleep_enable();
 sleep_mode(); // System sleeps here

 sleep_disable(); // System continues here 
 sbi(ADCSRA,ADEN); // switch Analog to Digitalconverter ON
}

void setup()
{
 pinMode(wakeUpPin, INPUT); 
 pinMode(pinLed, OUTPUT); 
 mySwitch.enableTransmit(tx);
 
 PCMSK |= bit (PCINT0); 
 GIFR |= bit (PCIF); // clear any outstanding interrupts
 GIMSK |= bit (PCIE); // enable pin change interrupts 
 sei();
}

ISR (PCINT0_vect) 
{
 ledState = digitalRead(0);
}

void loop() 
{

 system_sleep();

 if (ledState) {
   digitalWrite(pinLed, ledState);
   mySwitch.switchOn("01111", "00010"); // ZIBASE => B15 
   delay(500);
   digitalWrite(pinLed, !ledState);
 }

}

 

Le script pour Arduino

// **** INCLUDES *****
#include "LowPower.h"
#include  

// Use pin 2 as wake up pin
const int wakeUpPin = 2;
volatile int ledState = LOW;
#define tx 4 // Pin number for the 433mhz OOK transmitter

RCSwitch mySwitch = RCSwitch();

void wakeUp()
{
 // Just a handler for the pin interrupt.
 //Serial.println("RISING on D2");
 ledState = !ledState; 
 digitalWrite(13, ledState); 
 
}

void setup()
{
 // Configure wake up pin as input.
 // This will consumes few µA of current.
 pinMode(wakeUpPin, INPUT); 
 pinMode(13, OUTPUT); 
 Serial.begin(9600); // use the serial port
 mySwitch.enableTransmit(tx);
 
}

void loop() 
{
 attachInterrupt(0, wakeUp, CHANGE);
 // Enter power down state with ADC and BOD module disabled.
 // Wake up when pin changes
 LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF); 

 
 // Disable external pin interrupt on wake up pin.
 detachInterrupt(0); 
 
 // Do something here
 // Example: Read sensor, data logging, data transmission.
 if (ledState) {
   Serial.println("RISING on D2");
   mySwitch.switchOn("01111", "00010"); // ZIBASE = A15 ?? 00 15 11 
 }
 else {
   Serial.println("FALLING on D2");
 }
 delay(500);

}

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/.

Sonde température DS18B20 1-Wire intégrée à la ZiBase via Raspberry Pi

 

 

Sonde 1-wire DS18B20

Sonde 1-wire DS18B20

raspizibase

 

 

 

 

 

Pour quelques €uros vous trouverez facilement sur internet des montages avec sonde déjà pré-cablée.

ds18b20 pré-cablée

ds18b20 pré-cablée

Installation Matériel

Sonde 1-wire ​DS18B20​

shema-branchement-DS18B20

Raspberry Pi

Zibase

Installation Logiciel

module ZiBase.py modifié ( ajout méthode setVirtualProbe )

def setVirtualProbe(self, id, value1, value2=0, type=17):
 """
 Cette commande permet au système HOST d’envoyer dans ZiBASE une information de sonde virtuelle
 comme si celle-ci était reçue sur la RF.
 Probe type: 
 17 : Scientific Oregon Type
 20 : OWL Type
 """
 req = ZbRequest()
 req.command = 11 # Virtual Probe Event
 req.param1 = 6
 req.param2 = id # Sensor ID (e.g; 4196984322
 req.param4 = type
 binStr = '00000000'+ dec2bin(value2 & 0xFF) + '00000000' + dec2bin(value1 & 0xFFFF)
 req.param3= int(binStr,2)
 #req.param3 = value1
 #print binStr, req.param3
 self.sendRequest(req)

Installer le  module w1thermsensor:  https://github.com/timofurrer/w1thermsensor.git

w1thermsensor.zip

crontab

crontab -l
 
# Edit this file to introduce tasks to be run by cron.
# 
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# 
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').# 
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# 
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# 
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# 
# For more information see the manual pages of crontab(5) and cron(8)
# 
MAILTO=ericxxxx@gmail.com


# m h dom mon dow command
*/2 * * * * cd /home/pi/python/weather; sudo python temp.py >> temp.log

Création sonde ZiBase

 

zibase_web.php

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/

Accéder au suivi d’activité Zibase avec node JS

Voici un petit script javascript qui permet d’afficher la log de la Zibase en temps réel.
Je l’utilise fréquemment afin de suivre l’activité de la Zibase lors de l’installation d’un nouveau scénario dans la Zibase.
snapshot1screenshot sous windows

snapshot windows

Le script nécessite l’installation de nodejs logoNodeJs est disponible sous linux, Mac ou Windows.
J’ai testé le fonctionnement sous Ubuntu, Raspian ainsi que Windows7

Marche à suivre pour l’installation du script:

Avant tout, vérifiez la bonne installation de nodejs ainsi que de npm. Les commandes node -v et npm -v doivent retourner la version des applications:
Sous linux:

pi@raspi /var/log $ node -v
v0.10.2
pi@raspi /var/log $ npm -v
1.2.15

Sous Windows:
snapshot3snapshot windows

Une fois node et npm installés, téléchargez le fichier master.zip ou accédez au repository GitHub
Décompressez le fichier dans un répertoire (ex: zibase log, pour moi ce sera udp), vous obtenez:

eric@I7:~/Documents$ cd udp
eric@I7:~/Documents/udp$ ll
total 16
drwxr-xr-x 2 eric eric 4096 août   9 21:07 ./
drwxr-xr-x 6 eric eric 4096 août   9 21:08 ../
-rw-rw-r-- 1 eric eric 2132 août   9 18:30 app.js
-rw-r--r-- 1 eric eric  280 août   9 19:00 package.json
eric@I7:~/Documents/udp$ 

Il faut maintenant renseigner le script avec l’adresse IP de votre zibase, pour cela
éditez le fichier package.json et entrez l’adresse de votre zibase ( pour moi c’est 192.168.0.100)

eric@I7:~/Documents/udp$ cat package.json 
{
  "name": "zibase-log",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "wstart" : "SET IP_ZIBASE=192.168.0.100 && node app.js",
    "start": "export IP_ZIBASE=192.168.0.100; node app.js"
  },
  "dependencies": {
    "moment": "2.8.3"
  },
  "author": "onlinux",
   "date": "20140809"
}

Lancement du script

Assurez-vous que tous les modules nodeJs sont bien installés, sous Windows ou Linux tapez:

eric@I7:~/Documents/udp$ npm install

S’il manquait des modules, ceux-ci vont être téléchargés et installés.

Maintenant, il suffit de lancer le script.

Pour le lancer sous linux , tapez:

eric@I7:~/Documents/udp$ npm start

Sous Windows, tapez:

E:\node\udp\npm run wstart

vous devriez obtenir la log de la zibase en temps réel:

eric@I7:~/Documents/udp$ npm start

> zibase-log@0.0.1 start /home/eric/Documents/udp
> export IP_ZIBASE=192.168.0.100; node app.js


5a534947000d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0a80072000042cc000000000000000000000000
server listening 192.168.0.114:17100
Sat Aug 09 2014 21:10:49 GMT+0200 (CEST) Zapi linked to host IP=192.168.0.114 UDP Port=17100
Sat Aug 09 2014 21:10:51 GMT+0200 (CEST) Received radio ID (433Mhz Oregon Noise=2425 Level=3.3/5 Temp-Hygro Ch=1 T=+25.8C (+78.4F) Humidity=64%  Batt=Ok): OS439207425
Sat Aug 09 2014 21:10:52 GMT+0200 (CEST) Received radio ID (433Mhz Oregon Noise=2424 Level=5.0/5 Temp-Hygro Ch=2 T=+26.1C (+78.9F) Humidity=64%  Batt=Ok): OS439208706
^CCaught interrupt signal

Unregistering... 70
eric@I7:~/Documents/udp$ exit

Pour suivre l’activité lors de l’installation d’un nouveau scénario , sur mon raspberry pi, je
pipe la log et grep sur une chaîne de caractère ou un numero de scénario.
On peut enregistrer l’ensemble de l’activité dans un fichier pour une analyse ultérieure.
Bon, si vous utilisez linux, vous connaissez les commandes grep, pipe| etc… tout le nécessaire pour une recherche dans une log.

eric@I7:~/Documents/udp$ npm start | grep radio
Sat Aug 09 2014 21:32:45 GMT+0200 (CEST) Received radio ID (433Mhz Oregon Noise=2445 Level=5.0/5 Temp-Hygro Ch=2 T=+26.1C (+78.9F) Humidity=63%  Batt=Ok): OS439208706
Sat Aug 09 2014 21:32:50 GMT+0200 (CEST) Received radio ID (433Mhz Oregon Noise=2425 Level=5.0/5 Temp-Hygro Ch=1 T=+26.5C (+79.7F) Humidity=64%  Batt=Ok): OS439164929
Sat Aug 09 2014 21:32:57 GMT+0200 (CEST) Received radio ID (433Mhz Oregon Noise=2404 Level=3.5/5 Temp-Hygro Ch=1 T=+25.7C (+78.2F) Humidity=64%  Batt=Ok): OS439207425

Le script est très simple, il peut être conjuguer facilement à un serveur express pour accéder à l’ensemble des info Zibase ou bien créer un site comme il en existe déjà en php pour la zibase.

Exemple de sortie de log

Lors du réglage du FGMS-001 (ici ZWAVE ZA4), j’ai suivi l’activité pour voir l’effet de différentes mofifications sur les paramètres 42 (Intervalle de rapport de luminosité), 60 (Seuil de rapport de température) et 80 (mode de signalement des LED) du FGMS-001.

eric@I7:~/node/udp$ npm start | grep -v Oregon

snapshot2snapshot windows

Voilà, en espérant que cela puisse aider quelques utilisateurs de la Zibase lors de l’installation et test d’un nouveau scénario.

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.