blog i69

pense-bête, contre la perte de données de mes sites favoris...

Raspberry Pi - Utiliser des détecteurs sans-fils

Jeudi 05 février 2015 - Aucun commentaire

1) Le matériel :
Un récepteur 433Mhz

2) L'installation :
Connectez le récepteur 433Mhz selon le schéma suivant :


3) Le software :
Installez libcurl avec la commande suivante :

apt-get install libcurl4-openssl-dev

Vérifiez que WiringPi et Rcswitch-pi sont bien installés sur votre Raspberry.

4) Le code :

RCSwitch :

#include "RCSwitch.h"
#include 
#include 
#include 
#include      
     
RCSwitch mySwitch;
 
void send_motion(int value)
{
    CURL *curl;
  CURLcode res;

  curl = curl_easy_init();
  if(curl) {
    char url[200];
    sprintf(url,"%s%d","http://127.0.0.1/motion.controller.php?action=motion&sensor=",value);
    curl_easy_setopt(curl, CURLOPT_URL,url );

    res = curl_easy_perform(curl);

    if(res != CURLE_OK)
      fprintf(stderr, "curl_easy_perform() failed: %sn",
              curl_easy_strerror(res));

    /* always cleanup */
    curl_easy_cleanup(curl);
  }
}

int main(int argc, char *argv[]) {
  
     int PIN = 2;

     if(wiringPiSetup() == -1)
       return 0;

     mySwitch = RCSwitch();
     mySwitch.enableReceive(PIN);  // Receiver on inerrupt 0 => that is pin #2
    
     while(1) {
  
      if (mySwitch.available()) {
    
        int value = mySwitch.getReceivedValue();
    
        if (value == 0) {
          printf("Unknown encoding");
        } else {    
          printf("Received %in", mySwitch.getReceivedValue() );
          send_motion(value);
        }
        mySwitch.resetAvailable();
      }
    sleep(1.5);
  }
  exit(0);
}

Puis faites un "make"

Pour lancer le code, lancer la commande (dans le répertoire) :

sudo ./RFSniffer

Tags de l'article : ,

Raspberry Pi - Gérer les appareils électriques

Jeudi 05 février 2015 - Aucun commentaire

1) Le matériel :
Des prises télécommandées.
Un émetteur 433 Mhz.


2) Le montage :
Branchez l'émetteur RF 434Mhz au Raspberry Pi selon le schéma suivant :




3) logiciel :
Installez tout d'abord la librairie WiringPi en suivant les étapes suivantes :
- Installer Git :
sudo apt-get install git-core

- Téléchargez WiringPi avec la commande :
git clone git://git.drogon.net/wiringPi

- Puis installez WiringPi en vous plaçant dans le répertoire de WiringPi et en exécutant la commande ./build :
cd wiringPi
./build

- Installez maintenant rcswitch-pi avec la commande git : (vérifiez que vous êtes bien sorti du répertoire de WiringPi, si non, un "cd ../")
git clone https://github.com/r10r/rcswitch-pi.git

- Installez rcswitch-pi en allant dans le répertoire de rcswitch-pi et en exécutant la commande make :
cd rcswitch-pi
make


4) Comprendre le fonctionnement de rcswitch-pi et des prises :
Avec un tournevis, ouvrons une prise télécommandée.

Par exemple pour la prise télécommandée ci-dessus, pour allumer cette prise nous allons taper la commande :
(en étant dans le répertoire de rcswitch-pi bien évidemment)

./send 01111 4 1

Explication !
La première partie de la commande ( "01111" ) correspond au codage de la prise ( codage qui permet d'éviter les interférences si vous avez des voisins qui ont les mêmes... ). Pour traduire le codage que vous avez utilisez, prenez 0 quand l'interrupteur est en bas, et 1 quand il est en haut. La deuxième partie ( "4" ) est le numéro de la prise ( sachant que vous avez 4 prises fournies, la prise A correspond au code 1, la B au 2, etc... ! ). Et la troisième partie ( "1" ) correspond à l'état que nous voulons donner à la prise ( 0 pour "off" => éteindre la prise, 1 pour "on" => allumer la prise ).

5) Lancer une commande depuis une interface web
Ajouter dans le fichier sudoers ( /etc/sudoers en général ) de votre Raspberry la ligne suivante en fin de fichier :

www-data ALL=(ALL) NOPASSWD:ALL

Pour que l'utilisateur www-data ait les droits pour lancer une commande système !

Ensuite, il suffit de créer un fichier php, par exemple "prise.php", que l'on place dans le répertoire "www" du Rasp, avec le code suivant :

$status = $_GET['status'];
$numero_prise = $_GET['numero_prise'];
exec('sudo /home/pi/rcswitch-pi/./send 01111 '.$numero_prise.' '.$status);
Puis il suffit de faire une requête à l'URL suivante : ( en étant sur le même réseau que le rasp évidemment )

http://IP_RASP/prise.php?status=1&numero_prise=4

Ce qui aura pour effet d'allumer la prise n°4 ! ( la prise D)

Tags de l'article : , ,

FS 1000A 433 MHz une antenne pour améliorer la couverture

Jeudi 05 février 2015 - Aucun commentaire

L’idée aujourd’hui est d’augmenter la couverture du petit module émetteur FS 1000A, supposé couvrir jusqu’à 100 m :


en haut à gauche, l’émetteur, en bas à droite, le récepteur 433 MHz

Nous allons donc venir lui souder une antenne sur la broche ANT laissée libre, en choisissant la solution la plus simple, la plus économique :
recycler l’un de ces innombrables morceaux de fil métalliques qui entoure tout et n’importe quoi désormais.
Si si, regardez le cordon Ethernet que vous venez d’acheter, vous avez forcément l’un de ces petits bouts de métal recouvert d’une protection plastifiée !
C’est économique et cela fonctionnera à merveille, inutile d’aller dépenser 10 € pour une belle et vraie antenne, sauf bien entendu si vous avez envie de venir fixer tout ceci sur un joli boîtier.

Nous utiliserons 1/4 d’onde, ce qui sur 433 MHz donne environ 17.3 cm.
Un coup de pince coupante, un bout de dénudage à l’une des extrémités, un fer à souder bien chaud, et hop, le tour est joué :

Tags de l'article : , ,

Raspberry Pi - Détecter le facteur

Jeudi 05 février 2015 - Aucun commentaire

Emetteur 433 MHz miniature


Ce tout petit module est autonome.
Ajoutez lui une antenne (un fil de 17,4 cm exactement sur sa broche ANT), une pile miniature 12 V, et vous voici prêt à émettre vos premières trames de télécommande.
Ah oui, notez les jumpers D1 à D4 situés en bas à droite de l’image : ils permettent de générer un code bien précis, selon vos besoins.
Il faudra vous munir bien entendu d’une platine de réception 433 MHz raccordée à votre Raspberry Pi pour déterminer le code transmis, cf ce billet pour apprendre comment sniffer le code.
Dans mon cas, le module émet le code 13253135 par défaut, avec les jumpers par défaut.

Allons maintenant chercher un relai reed avec une sortie NC / NO : lorsque la boite aux lettres sera fermée, un petit aimant viendra établir la continuité entre le COMmun et la sortie NO.
Ouvres la boîte, l’aimant s’éloigne, et c’est le contact NC qui sera relié au COMmun, parfait pour venir alimenter notre petit module le temps nécessaire :




modifions un peu le script de réception présenté ici et venons lui ajouter la détection de notre mini-émetteur :

  elif g == 13253135:

    print ("reception mini tx 433 MHz")

# envoi SMS Freemobile sur ouverture boite aux lettres

#

    os.system('sudo sh /home/pi/sms.sh')

    os.system('sudo cp /home/pi/zero.txt /home/pi/recu.txt')

Le fichier sms.sh est lui des plus simple :

#!/bin/bash

curl --insecure 'https://smsapi.free-mobile.fr/sendmsg?user=12345678&pass=12345678&msg=boite%20ouverte'

Remplacez bien entendu les valeurs user et pass par vos propres informations d’abonné.

Il vous reste désormais à intégrer le petit interrupteur reed, le mini-émetteur et une batterie 12 V dans votre boite aux lettres,
voir à l’extérieur dans un boîtier électrique étanche, au besoin en ajoutant une antenne 433 MHz pour obtenir un maximum de portée :
à la première ouverture, votre Raspberry vous adressera un SMS :

boite ouverte

Tags de l'article : ,

Raspberry Pi - Réception télécom 433 MHz en tâche de fond avec 433Utils + RFSniffer + script Python

Jeudi 05 février 2015 - Aucun commentaire

Utiliser le petit module de réception 433 MHz sur le Raspberry Pi, sans être pour autant coincé sur la seule réception ?



En bas à droite, récepteur 433 MHz

Je m’explique : ce petit récepteur est installé avec les outils 433Utils (procédure d’installation sur ce billet).
Pour recevoir un code 433 MHz, la solution de base était de le récupérer via une simple commande :

sudo ./RFSniffer

chaque code reçu était alors affiché à l’écran du terminal, une méthode totalement inexploitable pour venir détecter le code, le comparer à une liste, et lancer des actions appropriées.
Par exemple, je reçois le code 12345, je détecte qu’il s’agit de mon alarme incendie, je peux donc envoyer un email d’alerte.
Avec le RFSniffer actuel, c’est impossible !

Nous allons donc légèrement modifier ce RFSniffer pour qu’il vienne enregistrer le code reçu dans un bête fichier .txt :

sudo su
nano ./RFSniffer.cpp

et modifions la partie qui se trouve sous } else { :

//
// Sauvegarde du code recu dans /home/pi/recu.txt
//
          FILE *f = fopen(« /home/pi/recu.txt », « w »);
fprintf(f, « %i », value );
//
// Supprimez ou commentez la ligne ci dessous pour n avoir aucun affichage
//
//          printf(« recu %i/n », value );
          fclose(f);

Lançons maintenant RFSniffer en tâche de fond :

./RFSniffer &

Il fonctionnera en permanence, et désormais tout code reçu se trouvera dans /home/pi/recu.txt, à vous alors de venir le récupérer. Si vous souhaitez interrompre RFSniffer, pensez à noter le nombre indiqué lors de son lancement en tâche de fond :

root@raspberrypi:~/433Utils/RPi_utils# ./RFSniffer &
[2] 2578
root@raspberrypi:~/433Utils/RPi_utils#

2578 ici, nous allons donc supprimer la tâche avec :

kill 2578

Si vous avez zappé ce nombre, exécutez la commande :

ps

et observez le résultat :

root@raspberrypi:~/433Utils/RPi_utils# ps
PID TTY          TIME CMD
2120 pts/0    00:00:00 sudo
2121 pts/0    00:00:00 su
2122 pts/0    00:00:01 bash
2578 pts/0    00:00:02 RFSniffer
2581 pts/0    00:00:00 ps
root@raspberrypi:~/433Utils/RPi_utils#

On identifie le processus RFSniffer, et son numéro de tâche : 2578 ! Simple non ? :-)

CONCLUSION :

Il ne vous reste désormais plus qu’à écrire un script avec une boucle lisant /home/pi/recu.txt et exécutant certaines commandes selon le code reçu, et à lancer RFSniffer au démarrage de la Framboise bien entendu.

Nous savons désormais comment recevoir un code dans un fichier stocké dans /home/pi/recu.txt, un processus mis en tâche de fond.

Au moyen d’un simple script rx2.py, placé dans /home/pi, nous allons pouvoir lancer des actions en fonction du code reçu (pensez à recréer les identations nécessaires à Python).

Nous allons commencer par copier recu.txt dans un fichier temporaire, temp.txt. Ouvrons alors ce fichier, lisons son code et lançons alors les actions appropriées :
    allumage du salon (un script .sh tout simple exécuté en arrière plan)
    extinction du salon
    activation du relai 0 du PiFace, sous forme de pression : j’appuie, je relâche, comme s’il s’agissait d’une pression sur une télécommande
    activation du relai 1 du PiFace

Pensez à créer un fichier /home/pi/zero.txt contenant juste le chiffre 0 (zero) sans rien d’autre.

Lancez le script simplement :

python3 rx2.py

Si vous voulez le faire tourner en tache de fond, ajoutez simplement un # devant les lignes contenant print, de façon à ce qu’aucun affichage ne vienne vous déranger, puis lancez le :
python3 rx2.py &




#!/usr/bin/python3
#
# Lecture du code de télécommande reçu par RFSniffer (version modifiée, en tâche de fond)
# le code reçu se trouve dans /home/pi/recu.txt
#
import os
#
# Boucle de detection sans fin
#
# var = 1
while True :
#
# on copie recu.txt dans temp.txt pour éviter de le lire alors que le processus RFSniffer l'utilise (plantage assuré)
#
os.system('sudo cp /home/pi/recu.txt /home/pi/temp.txt')
#
# Ouverture et lecture de temp.txt
#
f = open('/home/pi/temp.txt', encoding='utf-8')
g = int(f.read())
#
# détection du code
# puis remise à zero de recu.txt en copiant zero.txt à sa place
# (zero.txt contient un simple 0)
#

#
# activation relai 0 du PiFace : ON puis OFF
#
if g == 4195665:
print ("Relai 0")
os.system('sudo python /home/pi/output.py 0')
os.system('sudo cp /home/pi/zero.txt /home/pi/recu.txt')

#
# activation relai 1 du PiFace : ON puis OFF
#
if g == 4195668:
print ("Relai 1")
os.system('sudo python /home/pi/output.py 1')
os.system('sudo cp /home/pi/zero.txt /home/pi/recu.txt')

#
# télécommande du salon, lancement des scripts salon_on ou salon_off (envoi de trappes SNMP à un contrôleur 10 relais)
# à modifier selon les besoins, le code est indiqué dans g == xxxxxxxx: xxxxxxx = code de télécommande
#
elif g == 4198737:
print ("salon on")
os.system('sudo sh /home/pi/salon_on.sh &')
os.system('sudo cp /home/pi/zero.txt /home/pi/recu.txt')

elif g == 4198740:
print ("salon off")
os.system('sudo sh /home/pi/salon_off.sh &')
os.system('sudo cp /home/pi/zero.txt /home/pi/recu.txt')

Tags de l'article : , ,

Raspberry Pi - Télécommande 433 MHz universelle

Jeudi 05 février 2015 - Aucun commentaire

Faire reconnaitre un code de télécommande 433 MHz, et comment reproduire ce code en émission.

Sorties GPIO du PI :


La broche 1 est celle située la plus près de la LED rouge d’alimentation.
Utiliser les broches 2 et 4 pour le +5V nécessaire aux modules 433 MHz, les broches Ground pour la masse (GND) des modules.
Les broches 11 et 13 seront utilisées respectivement pour les datas en émission (11) et réception (13).


Raccordement des modules Tx / Rx 433 MHz
Sur l’image du montage, le module Tx se trouve en haut, le module Rx en bas à gauche, contre la télécommande Phenix.

Installation des gestionnaires, toujours en mode superutilisateur (sudo su depuis une connexion ssh).

Installation de WiringPi :

cd ~/
git clone git://git.drogon.net/wiringPi
cd wiringPi
./build

Installation de 433Utils :

cd ~/
git clone git://github.com/ninjablocks/433Utils.git
cd 433Utils/RPi_utils
make

Nous voici désormais munis de tous les outils pour recevoir et émettre des trames 433 MHz, mais attention, seulement sans Rolling Code, c’est à dire des télécommandes basiques, non cryptées.

Recevoir les codes :

Pour recevoir les codes, lancez la commande :

sudo ./RFSniffer

Une fois le code reçu, vous le verrez s’afficher à l’écran. Notez le pour une utilisation ultérieure.

Emettre un code :

L’émission d’un code est simple :

sudo ./codesend 12345

pour émettre le code 12345.

Ce petit montage, simplifié à l’extrême, va donc vous permettre de venir automatiser une télécommande existante, à condition que cette dernière ne soit pas sécurisée par rolling code.
A vous donc l’activation à distance via une petite interface Web, la programmation d’allumage ou d’extinction en fonction des heures via un crontab, l’activation sur détection de mouvement, etc.

Tags de l'article : , ,