Raspberry : réception 433 MHz en tâche de fond avec 433Utils
Problématique du jour : comment utiliser le petit module de réception 433 MHz sur le Raspberry Pi, sans être pour autant coincé sur la seule réception ?
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.
Au boulot 🙂
Merci pour ton tuto
je n y connais rien en programmation mais avec beaucoup de bonne volonté j arrive a comprendre, a reproduire et a « depanner »
J ai un soucis avec ton rajout :
– faut il le faire avant le make ?
– si oui j ai essayer et bonjour les erreurs de non déclaré.
– si non : chez moi le fichier.txt ne ce cree pas.
Est il possible de partage ton fichier RFSniffer.cpp ?
Nous sommes deux alors, mais on apprend vite en surfant un peu 🙂
Oui, il faut modifier le .cpp AVANT de faire le make. Une fois fait, il compile avec make et hop, ça fonctionne.
Voici mon RFSniffer.cpp in extenso, il va écrire le code reçu dans /home/pi/recu.txt. Tu peux vérifier la réception du code en supprimant les // en début de ligne, j’ai rajouté des commentaires en français pour aider. Pour le lancer en tâche de fond, ajoute un espace et le signe & simplement. Bien penser à le « killer » par contre AVANT toute modif, compilation et re-lancement :
/*
RF_Sniffer
Hacked from http://code.google.com/p/rc-switch/
by @justy to provide a handy RF code sniffer
*/
#include « RCSwitch.h »
#include
#include
RCSwitch mySwitch;
int main(int argc, char *argv[]) {
// This pin is not the first pin on the RPi GPIO header!
// Consult https://projects.drogon.net/raspberry-pi/wiringpi/pins/
// for more information.
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 {
//
// Sauvegarde du code recu dans /home/pi/recu.txt
//
FILE *f = fopen(« /home/pi/recu.txt », « w »);
fprintf(f, « %d », value );
//
// Supprimez la ligne ci dessous pour n avoir aucun affichage
//
// printf(« recu %i\n », mySwitch.getReceivedValue() );
// printf(« recu %d\n », value );
fclose(f);
}
mySwitch.resetAvailable();
}
}
exit(0);
}
Super merci !
1 – Sur le site je lis, copie et colle des « erreur de compilation – alors que chez moi je dois mettre des « , du coup je venais juste de resoudre le probleme.
2 – Je souhaite utiliser ta modif pour « ecouter » les telecommande et ainsi mettre a jour mon system domoticz
Explication : biensur je vais utiliser mon install domo avec mon rpi, ma tablette et mon tel et meme ouvrir et fermer le portail en fonction de ma position gps (via tasker, le plug ssh et codesend),
Mais ma femme elle pense télécommande, je veux allumer, j’appuie sur le bouton on, je veux eteindre, j’appuie sur le bouton off.
Domoticz de son coter a en memoire le dernier etat qu il a donner aux prises, il ne connait pas l’action des telecommandes.
J’en arrive a vouloir ecouter les telecommandes, enregistré les codes emis par elle (date heure code) et les sauvegarder en log.
Ta modification de RFSniffer cree un fichier a chaque nouveau code, au lieu de le mettre a jour, as tu une idée pour modifier cela ?
ah non, ici le RFSniffer ne me génère pas un fichier par code : il remplace le code se trouvant précédemment dans recu.txt par le nouveau code reçu, et c’est tout. Si tu as un fonctionnement différent, ça ne provient pas de RFSniffer à priori car je confirme, je n’ai qu’un recu.txt.
Avec un script python, je vais aller lire recu.txt en boucle, vérifier s’il y a un changement, et dans ce cas là lancer un code, un script, etc. avant de revenir scanner recu.txt pour un nouveau code, et ainsi de suite.
J’avais imaginer pouvoir générer une sorte d’interruption à chaque code reçu, mais là je manque de compétences en programmation pour bien faire 🙂
Ok j’avais bien compris le principe du remplacement et a la limite cela me va meme si de temps a autre j’ai un code parasite qui apparait quand j actionne un bouton des telecommandes.
J’ai bien compris ton principe de fonctionnement, RFSniffer en espion est une bonne solution, a moi d aller dire a domoticz de lire recu.txt en boucle.
Encore merci pour ton aide
Ah le code parasite, j’ai aussi oui, mais comme il ne correspondra de toute façon à rien dans le script de lecture de codes, ça importe peu.
Si domoticz peut lancer un script python, voici comme je lis recu.txt, en prenant soin de vérifier qu’il n’est pas vide, sinon erreur de script. J’utilise un fichier zero.txt qui contient un simple ZERO (0, à créer de préf avec l’éditeur jed car nano ajoute systématiquement un retour à la ligne) pour venir « réinitialiser » recu.txt une fois lu :
#!/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
import time
#
# Boucle de detection sans fin
#
# var = 1
while True :
#
# Ouverture et lecture de recu.txt
#
f = open(‘/home/pi/recu.txt’, encoding=’utf-8′)
#
# Detectons si le fichier est vide (0) ou pas et placons son contenu dans la variable g
#
statinfo = os.stat(‘/home/pi/recu.txt’).st_size
if statinfo > 0 :
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 »)
#
# activation du relai 0 de l’interface PiFace
# en lancant un script python output.py
#
# os.system(‘sudo python /home/pi/output.py 0’)
#
# et on efface recu.txt en lui mettant un joli 0
#
os.system(‘sudo cp /home/pi/zero.txt /home/pi/recu.txt’)
Super merci beaucoup !
Domoticz lit les Pythons, et permet de mettre a jours l’etat des « devices » via json.
Il me reste a modifier ton script pour y ajouter le json de mise a jour.
Pour ecrire dans un fichier j’ai modifier le RFSniffer.cpp comme ceci :
#include
else {
printf(« %i\n », mySwitch.getReceivedValue() );
std::ofstream fichier(« /home/pi/donnees.txt »);
fichier << mySwitch.getReceivedValue();
fichier.close();
}
Bonjour, j’ai essayé la modification de mon fichier RFSniffer.cpp avec l’ajout des lignes pour enregistrer dans un fichier texte mais rien ne se passe. Il faut dire que la partie « make » m’est inconnue.
Si je comprends bien, tant que le rpi est lancé, le fichier d’origine reste celui utilisé à chaque demande.
Pourriez-vous me préciser la méthode pour remplacer ce fichier ?
Merci par avance.
Tiboys
Oui, s’il n’y a pas eu de compilation avec make, le .cpp modifié n’est pas pris en compte.
Il faut installer le compilateur sur le Raspberry donc, pour pouvoir compiler, etc.
Merci beaucoup pour votre aide. Je vais donc chercher à installer un compilateur sur mon rpi pour modifier ce fichier
à priori sudo apt-get install make devrait le faire, si je ne me trompe pas trop.
merci pour le code, j’avais finalement réussi à l’installer grâce à cette ligne : « apt-get install build-essential ».
Ensuite la commande « g++ RCSwitch.o RFSniffer.cpp -o RFSniffer -lwiringPi » a permis de compiler et ça fonctionne. Je souhaiterais toutefois une modification à ce nouveau code .. que le fichier texte ne conserve qu’une ligne .. hors là i revient à la ligne et en ajoute un autre. Mon fichier risque de devenir très long à force. J’ai bêtement tenté d’insérer une ligne type « fseek ($fp, 0); » mais j’obtient désormais une erreur lorsque je compile. Avez-vous une solution ?
Encore merci pour votre aide.
Je me réponds .. j’avais mis a et non w .. du coup ça ajoutait la suite .. 🙁
bon ben tout marche alors ? 😉
Je suis curieux, quel est le projet pour ce RFSniffer du coup ?
Ici la domotique a pas mal évolué, elle détecte désormais des entrées, des mouvements, via les petits ESP8266 et toujours le Raspi en chef d’orchestre 😉
oui tout fonctionne .. j’ai cru voir passer un script qui permet de lire un fichier texte et lancer des actions en fonction. J’ai tenté le tuto d’idleman mais je n’arrive pas à faire tourner son radioreception .. ça fait juste mouliner la tite bête. Mon utilisation du rfsniffer étant de simplifier l’utilisation du rpi .. j’ai demandé à une page web d’afficher le contenu du fichier txt .. il me reste à trouver comment lancer rfsniffer à chaque démarrage ( ou le lancer via une commande onclick ). Mon rpi me sert principalement à ouvrir mes volets ( relais filaires ) et allumer prises ( émission de codes récupérés avec rfsniffer ) . le tout en local ou à distance grâce au serveur web installé .. très, très pratique 😉 Mes pages web sont plus des bidouillages de pages récupérées à mes besoins que des conceptions .. ce qui lui ferait pas de mal mais je ne maîtrise pas assez !!
Alors, pour lancer au boot, il faut éditer /etc/rc.local et ajouter la ligne sudo /le_bon_chemin/RFSniffer &
Le & permet de le démarrer en tâche de fond, plutôt pratique pour ne pas être coincé.
Déjà, là, il sera simple de faire un « cat recu.txt » après chaque envoi de code 433 MHz, et voir s’il capte bien. C’est la première chose à tester avant de venir lire recu.txt et détecter son contenu.
merci pour la réponse, il faut ajouter cette ligne après exit 0 ?
Le contenu de mon fichier possède déjà : _IP=$(hostname -I) || true
if [ « $_IP » ]; then
printf « My IP address is %s\n » « $_IP »
fi
exit 0
Bonjour merci pour vos commentaires qui m’ont jusqu’ici bien aidés pour démarrer mon kit E/R 433Mhz avec RFSniffer.
Je n’arrive pas à compiler RFSniffer.cpp dès lors que j’ajoute les commandes permettant d’ouvrir le fichier recu.txt
Voici le code erreur affiché lors de la compilation
RFSniffer.cpp:47:7: error: stray ‘\302’ in program
FILE *f = fopen(« /home/pi/recu.txt », « w »);
J’ai bien ajouté les droits nécessaires pour pouvoir ouvrir le fichier en écriture depuis l’utilisateur Pi…
J’ai l’impression qu’il me manque l’inclusion d’une librairie permettant d’utiliser la fonction « fopen ».
Pouvez-vous éclairer ma lanterne car ca fait quelques heures que je galère sans trouver de solution…
Merci pour votre aide!!!
bonjour à tous désolé j’ai trouvé il s’agissait de l’utilisation du caractère » qui était interprété par mon navigateur web puis collé dans le fichier .cpp avec le mauvais format.