blog i69

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

Raspberry Pi - Raspbian

Mercredi 18 février 2015 - Aucun commentaire

sudo apt-get update
sudo apt-get -y upgrade
sudo apt-get -y dist-upgrade

sudo apt-get install ca-certificates git-core
sudo wget https://raw.github.com/Hexxeh/rpi-update/master/rpi-update -O >/usr/bin/rpi-update && sudo chmod +x /usr/bin/rpi-update

uname -a
sudo rpi-update
sudo reboot
uname -a

sudo apt-get install screen
sudo apt-get install php5-cli php-apc
sudo service apache2 restart
php -v

screen -dmS Raspcontrol sh ./start.sh

crontab -e
@reboot cd Raspcontrol && screen -dmS Raspcontrol sh ./start.sh

Tags de l'article : ,

Raspberry Pi - Serveur de musique en ligne de commande

Jeudi 05 février 2015 - Aucun commentaire

1) Installez MOC :
un lecteur audio/serveur de musique en ligne de commande

sudo apt-get install moc


2) Les commandes disponibles :
Lancer le serveur MOC :
mocp -S

Ajouter un répertoire ou un fichier à la playlist :
mocp -a /nom_du_repertoire/

Passer en mode aléatoire :
mocp -t shuffle

Jouer le premier titre de la playlist :
mocp -p

Jouer la piste suivante :
mocp -f

Jouer la piste précédente :
mocp -r

Arrêter la lecture :
mocp -s

Basculer entre la lecture et la pause :
mocp -G

Arrêter la musique et le serveur MOC :
mocp -x


3) Lancer la musique via une requête http :
Ajouter l'utilisateur www-data au groupe audio
Ajouter l'utilisateur au sudoers en rajoutant "www-data ALL=(ALL) NOPASSWD:ALL" à la fin du fichier /etc/sudoers

sudo adduser www-data audio

Créer un dossier où placer la musique, par exemple /var/www/music.
Ainsi, toute la musique placée dans ce dossier sera lue par MOC ( même dans les sous-dossiers ).

Enfin, il suffit de créer un fichier PHP, qui lancera MOC/le stoppera.
"moc.php" :

<?php
if(isset($_GET['music']) && $_GET['music'] == "on")
{
	exec('mocp -S');
	exec('mocp -c');
	exec('mocp -a /var/www/music');
	exec('mocp -t shuffle');
	exec('mocp -p');


}
else if(isset($_GET['music']) && $_GET['music'] == "off")
{
	exec('mocp -x');
}
?>

Ainsi, par exemple lorsqu'on appelle l'URL :
http://IP_RASP/moc.php?music=on

La musique placée dans votre dossier de musique sera lancée en aléatoire ! ( la commande "mocp -c" sert à effacer la dernière playlist jouée, pour ne pas avoir le même ordre de musique à chaque fois).

Tags de l'article : ,

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 : , ,

Raspberry Pi - Installer apache, node.js, mpg321

Jeudi 05 février 2015 - Aucun commentaire

1) Faites une mise à jour des paquets
sudo -v
sudo apt-get update
sudo apt-get upgrade

2) Installer les paquets Apache, MySQL et PHP
sudo apt-get install apache2 php5 mysql-server libapache2-mod-php5 php5-mysql

3) Installer PhpMyAdmin
sudo apt-get install phpmyadmin
sudo ln -s /usr/share/phpmyadmin /var/www/phpmyadmin

4) Installer Node.js
sudo apt-get update && sudo apt-get install nodejs npm


5) Installez mpg321
sudo apt-get install mpg321

6) Créez un fichier PHP
"speak.php" :
<?php
exec('mpg321 "http://translate.google.com/translate_tts?tl=fr&q=Bonjour"');
?>

7) Ajoutez l'utilisateur www-data au groupe audio
sudo adduser www-data audio

8) Testez
Placez ce fichier PHP dans le dossier "/var/www" de votre Raspberry.
Puis, tapez dans un navigateur l'adresse de votre Raspberry, suivi du nom de votre fichier PHP, par exemple : http://IP_RASP/speak.php
Normalement, si votre Raspberry est connecté à un haut-parleur/casque et à internet, vous devriez entendre "Bonjour" !

9) Faire dire ce qu'on veut au Raspberry
Il suffit de remplacer "bonjour" par une variable dans notre fichier speak.php

<?php
if(isset($_GET['text']))
{
	exec('mpg321 "http://translate.google.com/translate_tts?tl=fr&q='.urlencode($_GET['text']).'"');
}
?>

Ainsi il vous suffira d'appeler l'adresse "http://IP_RASP/speak.php?text=" suivi du texte (encodé pour une URL bien évidemment), pour que le Raspberry s'exprime.



Autres :

Ajouter www-data aux sudoers en rajoutant "www-data ALL=(ALL) NOPASSWD:ALL" à la fin du fichier /etc/sudoers.


Avec Mplayer :
mplayer "http://translate.google.com/translate_tts?tl=fr&q=$MESSAGE"
dans un script bash.

Exemple :
#!/bin/bash # pré-requis : bc # Message de réveil de Jarvis # récupération de l'heure HEURE=$(date +'%k') # récupération des minutes (à vérifier, pas facile de viser la minute zéro) MINUTE=$(date +'%M') if [ $MINUTE > 0 ] then MINUTXT=" "$MINUTE else MINUTXT="" fi # récupération du nom du jour NOMJOUR=$(date +'%A') # récupération du jour NUMJOUR=$(date +'%d') # récupération du nom du mois NOMMOIS=$(date +'%B') # récupération de l'année ANNEE=$(date +'%Y') MESSAGE="Bonjour. Nous sommes le "$NOMJOUR" "$NUMJOUR" "$NOMMOIS" "$ANNEE", et il ai "$HEURE" heure"$MINUTXT mplayer "http://translate.google.com/translate_tts?tl=fr&q=$MESSAGE"


Pour utiliser les voix de voxygen :
exec('sudo mpg321 -g 100 "http://www.voxygen.fr/sites/all/modules/voxygen_voices/assets/proxy/index.php?method=redirect&text='.urlencode($_GET['text']).'&voice='.urlencode($_GET['voice']).'&ts=14030902642"');

Faites parler votre Rpi en tapant l'url suivante :
http://IP_RASP/speak.php?voice=[VOIX]&text=[VOTRE_TEXTE] Pour [VOIX].
Prenez le nom de la voix sur le site de Voxygen. (Exemples : Agnes, Eva, Damien, Philippe, Zozo, etc...)


Avant de lancer une commande mpg321, tuez celles en cours.

system('killall mpg321');
ou
exec('killall mpg321');

Tags de l'article :

Raspberry Pi - Envoyer des mails en ligne de commande

Jeudi 05 février 2015 - Aucun commentaire

Installation de SSMTP :
sudo apt-get update
sudo apt-get install ssmtp

Configure SMTP
sudo nano /etc/ssmtp/ssmtp.conf

Ajouter ces lignes :
root=username@gmail.com
mailhub=smtp.gmail.com:465
rewriteDomain=gmail.com
AuthUser=username
AuthPass=password
FromLineOverride=YES
UseTLS=YES

Pour envoyer un mail :
ssmtp mail.address@example.com
subject: this is a test
hellow world!

Envoyer une pièce jointe :
Installation de Mpack
sudo apt-get install mpack
mpack -s subject picture.png mail.address@example.com

Tags de l'article : , ,

Raspberry Pi - Détection, photo, mail

Jeudi 05 février 2015 - Aucun commentaire

Suite de nos expérimentations avec le Raspberry Pi, cette fois-ci sur un modèle B+ :


Nous avons donc équipé la Framboise de quelques éléments très simples :

une caméra HD
un détecteur de mouvement (PIR)
une broche de sortie

L’idée pour ce projet est de réaliser un système allumant une lampe ou une alarme sur détection de mouvement, avec capture d’une image et envoi immédiat par mail.
On peut naturellement envisager tout un tas d’applications :

vérifier qui s’est présenté à la porte de votre domicile
surprendre les animaux nocturnes dans une forêt, un champ
surveiller une habitation
surveiller un véhicule, un garage


Pour une surveillance intérieure, on peut prévoir d’ajouter une entrée sur le Raspberry Pi, une entrée qui va détecter si le module doit être activé ou pas (une clé, un clavier extérieur, etc), selon votre présence ou votre absence.
Fermée, l’entrée indiquera au système que le script peut détecter le mouvement.
Ouverte par contre, le script n’ira pas plus loin.

Le montage est très simple, il suffit de connecter les ports du détecteur directement au GPIOs du Raspberry Pi en suivant le schéma suivant :


Vous remarquerez deux vis oranges sur le capteur :
- La première sert à régler la sensibilité du capteur ( la valeur par défaut est 50% )
- La deuxième sert à ajuster la durée pendant laquelle le capteur va monter à 3V en sortie quand il a détecté un mouvement.
(Par défaut, quelques secondes)

Le script en Python 3 est relativement simple, je me suis inspiré d’un exemple obtenu ici :

wget http://www.raspberrypi-spy.co.uk/archive/python/pir_1.py

#!/usr/bin/python
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#|R|a|s|p|b|e|r|r|y|P|i|-|S|p|y|.|c|o|.|u|k|
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#
# pir_1.py
# Detect movement using a PIR module
#
# Author : Matt Hawkins
# Date   : 21/01/2013

# Import required Python libraries
import RPi.GPIO as GPIO
import time
import urllib

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

# Define GPIO to use on Pi
GPIO_PIR = 7

print "PIR Module Test (CTRL-C pour quitter)"

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

Current_State  = 0
Previous_State = 0

try:

  print "Waiting for PIR to settle ..."

  # Tourne en boucle jusqu a ce que la sortie du capteur soit 0
  while GPIO.input(GPIO_PIR)==1:
    Current_State  = 0    

  print "  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
      print "  Mouvement detecte !"
      test = urllib.urlopen("http://127.0.0.1/action.controller.php?action=motion")
      # On attend 80 secondes
      time.sleep(80) 
      # On enregistre l'ancien etat
      Previous_State=1
    elif Current_State==0 and Previous_State==1:
      # Le capteur est a nouveau pret
      print "  Ready"
      Previous_State=0
      
    # On attend 10 millisecondes
    time.sleep(0.01)      
      
except KeyboardInterrupt:
  print "  Quit" 
  # Reinitialisation des parametres GPIOs
  GPIO.cleanup()

Pour lancer le script vous n'avez qu'à taper la commande suivante :
sudo python pir.py


Voici donc le PHP qui va être appelé quand un mouvement est détecté.
Dès qu'un mouvement est détecté, on enregistre dans un fichier l'heure et la date du mouvement, et on la compare avec l'heure du dernier mouvement, pour en déduire des informations.

"action.controller.php" :
<?php
public function motion()
{
	$fichier_motion = fopen("motion_history.txt","r+");
	$old_date = fgets($fichier_motion);
	fclose($fichier_motion);
	unlink("motion_history.txt");
	$fichier_motion = fopen("motion_history.txt","a");
	fputs($fichier_motion,date('Y-m-d H:i:s'));
	fclose($fichier_motion);
	// Si l'utilisateur est entrain de dormir
	// CAD si un mouvement a été détecté il y a moins de 8 heures ET qu'il est encore nuit ( heure < l'heure de levé maximum)
	if((time() - strtotime($old_date)) < 8*60*60 && intval(date("H")) < $this->time_wake_up_max )
	{
		// ne rien faire
	}
	else if((time() - strtotime($old_date)) > 60*40)
	{
		// Sinon, si il y n'a pas eu de mouvement depuis 40minutes, c'est que l'utilsateur était parti
		// Donc => on l'accueil avec la fonction bienvenue()
		$this->bienvenue();
	}
}
?>


Pour la configuration de l’envoi de mails via le service smtp, je me suis inspiré de ce site et de ses exemples de configuration.
Une simple ligne ajoutée dans le script Python 3 et l’image est transmise sur un compte gmail :

os.system (‘sudo mpack -s ALERTE /var/www/alerte.jpg monemail@gmail.com’)

La capture d’images se fait en important le module picamera en tout début de script et en l’utilisant de façon extrêmement simple :

#
# CAPTURE D IMAGE
# sauvegarde dans /var/www/alerte.jpg
#
      with picamera.PiCamera() as camera:
        camera.vflip = True
        camera.hflip = False
        camera.resolution = (1024, 768)
        camera.start_preview()
        camera.capture(‘/var/www/alerte.jpg’)
        camera.stop_preview()

La sauvegarde se fait donc dans le fichier alerte.jpg, situé dans le répertoire /var/www.
Vous l’aurez donc compris, il vous faudra installer un serveur Apache2 au préalable, par exemple pour venir consulter l’image ainsi capturée en vous rendant directement sur l’ip de votre Raspberry au moyen du navigateur.

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 : , ,