jeudi 9 janvier 2014

[RaspberryPI] Sécurité, un détecteur d'ouverture de porte qui alerte par email

Les sources qui m'ont permis de réaliser ce tuto :
lien1 : http://learn.adafruit.com/playing-sounds-and-using-buttons-with-raspberry-pi/overview
lien2 : http://www.cyberciti.biz/tips/linux-use-gmail-as-a-smarthost.html

Dans ce tuto, nous allons mettre en place un détecteur d'ouverture de porte qui alertera par mail à chaque ouverture de porte.

Pré-requis

1) Avoir une RaspberryPI fonctionnelle avec Raspbian Wheezy chargé sur la carte SD
2) La carte aura un accès internet configuré en Wifi ou Ethernet
3) Un accès SSH configuré

Matériel

On utilisera
- une RaspberryPI
- un dongle Wifi (ou un cable réseau si la box n'est pas loin),
- un bouton poussoir
- une résistance de 10KOhms
- des fils pour connecter le tout

Envoyer des emails depuis une RaspberryPI

Tout d'abord, il faut se créer une nouvelle adresse email qui servira à envoyer les emails. J'ai choisi d'utiliser gmail, mais vous pouvez utiliser n'importe quelle fournisseur (free, yahoo, etc...).
1) Une fois le compte créé, connectez vous sur la RaspberryPI en SSH.

On va mettre à jour le dépot avant toute chose :
sudo apt-get update

On va installer ssmtp pour envoyer des emails car c'est la solution la plus simple que j'ai trouvé...
sudo apt-get install ssmtp

Ensuite on va rentrer les paramètres du compte mail créé. Placez vous à la fin du fichier /etc/ssmtp/ssmtp.conf et ajoutez les lignes suivantes en modifiant les champs en fonction du compte créé :
AuthUser=[identifiant]@gmail.com
AuthPass=[pass]
FromLineOverride=YES
mailhub=smtp.gmail.com:587
UseSTARTTLS=YES
On va ensuite exécuter quelques commandes pour assurer à ssmtp de prendre en charge l'envoi des mails
1) Arrêt des services sendmails
service sendmail stop
2) Créer un dossier de backup de sendmail et y placer l'ancien sendmail
mkdir /root/.backup
mv /usr/sbin/sendmail /root/.backup
3) Créer un lien de sendmail vers le dossier ssmtp 
ln -s /usr/sbin/ssmtp /usr/sbin/sendmail

Il est temps de tester, lancer la commande suivante en entrant une adresse mail à la fin
echo "test" | mail -s "test" votreAdresse@mail.com
NB : ceci enverra un mail votreAdresse@mail.com

Le bouton et la gestion de l’événement sur la RaspberryPI

On va utiliser python pour surveiller le bouton et la librairie permettant de gérer les port GPIO via python.
sudo apt-get install python-dev
sudo apt-get install python-rpi.gpio

Branchement

Pour le branchement, c'est assez simple on va procéder comme sur une carte Arduino. On va utiliser un bouton poussoir et une résistance de rappel (pour ne pas générer d'erreurs).

Brancher de cette manière (désolé pour le schéma) :
5V --- bouton --|-- résistance 10KOhms --- GND
                          |
                   GPIO17

Code 

Place au code python!
Créez un fichier raspi_button.py dans un dossier dédié de votre home :
sudo nano raspi_button.py

et insérer le code suivant (en prenant soin de modifier l'adresse mail) :
#!/usr/bin/env python

from time import sleep
import os
import RPi.GPIO as GPIO

#On initialise la pin GPIO17
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN)

while True:
        #Si un événement push est relevé on rentre dans la boucle, si on veut l'inverse on remplace True par False
        if ( GPIO.input(17) == True ):
                print('open!')
                #on envoit un mail
                os.system('echo "La porte est ouverte" | mail -s "Ouverture" votreAdresse@mail.com
                #on attend 5 secondes avant de laisser le programme repartir
                sleep(5);
        sleep(0.1);

Test

Lancer le programme 
sudo python raspi-button.py

Et appuyer sur le bouton, un mail devrait arriver

Evolution

C'est un programme assez simple et qu'on peut facilement transformer. Evidemment à chaque fois qu'on appui, un mail est envoyé, il faudrait ajouter des créneaux horaires d'alerte.

mercredi 1 janvier 2014

[Arduino Leonardo] Faire bouger le pointeur de la souris à l'aide d'un joystick

On va utiliser les 2 articles précédents sur les joysticks.



Dans ce tuto, on va faire bouger la souris de l'ordinateur à l'aide du joystick. Un peu comme le NunChuk de la console Wii (Oui on pourrait utiliser directement un NunChuk mais ici on réutilise les vieux composants d'une vieille manette! UpCycling!)

Programme


int sensorPinX = A0;
int sensorValueX = 0;
int sensorPinY = A1;
int sensorValueY = 0;
int speedMax = 50;
int baseMin = 450;
int baseMax = 550;


void setup() {
  Serial.begin(9600);
  Mouse.begin();
}

void loop() {
  sensorValueX = analogRead(sensorPinX);    
  sensorValueY = analogRead(sensorPinY);    
  if(sensorValueX>baseMax || sensorValueX<baseMin){
    float posX = map(sensorValueX, 0, 1023, -speedMax, speedMax);
    Mouse.move(0, posX, 0);
  }
  if(sensorValueY>baseMax || sensorValueY<baseMin){
    float posY = map(sensorValueY, 0, 1023, -speedMax, speedMax);
    Mouse.move(posY, 0, 0);
  }
  Serial.print(sensorValueX);
  Serial.print(";");
  Serial.println(sensorValueY);
  delay(50);
}
 
On a repris le même programme que l'article précédent en ajoutant la gestion de la souris.
On ajoute dans le setup la déclaration de la gestion de souris.
Dans le loop j'ai ajouté 2 conditions car je ne voulais pas avoir un mouvement de souris continu. Je ne traite les valeurs uniquement lorsque le joystick n'est plus en position repos (comprise entre 450 et 550 mais on peut revoir ces valeurs).

Uploadez le programme sur votre carte Arduino Leonardo (ca ne marchera pas avec une carte Arduino Uno) et testez.

La vitesse se règle avec la variable speedMax.
ATTENTION à ne pas trop rapprocher les valeurs de baseMin et baseMax sinon la souris va bouger sans arrêt. Si tout devient incontrôlable vous pouvez tout arrêter le processus en appuyant sur le bouton reset de l'Arduino.

[ARDUINO] Récupérer la position du joystick

Comme on a vu dans l'article précédent, il est très facile de récupérer des pièces électroniques. Réfléchissez avant de jeter vos vieux caméscopes, imprimantes, et autres matos électroniques!

Nous avons donc récupérer ceci
Dans l'article précédent on a identifié les connections au fil :
Rouge = 5v
Noir = data
Blanc = Ground (Gnd)

On laisse tomber les fils verts pour l'instant!

On connecte les fils

On saisit notre carte, et on branche les fils rouges sur le 5v de la carte, le blanc sur le Ground.
Les 2 fils noirs restant correspondent aux données de chaque axe X et Y. On branche un fil sur Analog0 et l'autre sur Analog1.

Programme

int sensorPinX = A0;
int sensorValueX = 0;
int sensorPinY = A1;
int sensorValueY = 0;


void setup() {
  Serial.begin(9600);
}

void loop() {
  sensorValueX = analogRead(sensorPinX);    
  sensorValueY = analogRead(sensorPinY);    
  Serial.print(sensorValueX);
  Serial.print(";");
  Serial.println(sensorValueY);
  delay(100);
} 

La méthode setup, qui je rappelle est exécuté à l'initialisation de la carte, démarre le serial à 9600 bauds, ce qui va nous permettre de visualiser la position du joystick.
Dans la méthode loop, qui je rappelle s’exécute sans arrêt, on va récupérer la valeur du A0 et A1 et écrire ces valeurs dans le serial séparé par un point-virgule. Et pause 100 millisecondes avant de redémarrer.

Branchez votre carte Arduino sur le port USB et uploadez le programme sur la carte.

Résultat

Si des chiffres s'affichent, c'est bon signe!
En position repos (sans effectuer de pression sur le joystick) les chiffres devraient être d'environ 500. Environ la moitié de 1023, puisque la valeur est comprise entre 0 et 1023.

Votre imagination sera votre seule limite!

[Arduino] S'interfacer avec un joystick de manette de console de jeux

 Je vais régulièrement à la pêche aux accessoires auprès de mes amis. Ils ont tous dans leurs placards des tas d'objets électroniques qu'ils n'utilisent plus.
Un d'eux m'a ramené une manette de Playstation 2.


J'ai tout de suite pensé à l'adapter avec la librairie qui permet d'utiliser une manette PS2 sur Arduino.
http://www.billporter.info/2010/06/05/playstation-2-controller-arduino-library-v1-0/
Malheureusement cette manette s'est avérée non compatible.
Ni une ni deux, je la démonte!

On y trouve 2 moteurs vibrants et surtout 2 joysticks.

On va dans ce tuto s'intéresser aux joysticks.

Comment ça marche?

Un joystick est souvent composé de 2 résistances variables X et Y ainsi qu'un bouton central.
Grâce à une carte Arduino, on va pouvoir récupérer la position exact du joystick en X et en Y comme si on récupérait la valeur d'un potentiomètre.
La valeur peut varier de 0 à 1023 et par défaut le joystick est positionné au milieu des 2 axes.

Vérifier qu'il fonctionne

Pour vérifier que le joystick fonctionne, on va le tester à l'aide d'un multimètre. Cette étape va nous aider à identifier les bornes du joystick!
Dans mon cas, j'ai 8 fils sur la broche. Chaque axe comporte 3 fils (rouge, blanc et noir) et le bouton centrale comporte 2 fils (vert). Il se peut que votre joystick n'est pas de bouton central, il n'y aura pas de fils verts...

Bref adaptez!

Les fils de chaque axe X et Y doivent être regroupés. Identifier les 3 fils d'un axe. Prenons à présent le multimètre et positionnez le sur résistance ou ohms, et placez le fil rouge du multimètre sur le fil rouge de l'axe X ou Y du joystick. Ensuite placez le fil noir du multimètre sur un des 2 autres fils du même axe. Si votre bouton est en position central et que vous obtenez environ 10kohms, vous avez identifié le ground (GND) si vous avez une valeur d'environ 5kohms, vous avez identifié la sortie analogique.
Si vous êtes dans le 2ème cas, essayez de bouger le bouton tout en conservant les connexions. Vous devriez voir la valeur du multimètre varier entre 0 et 1023.
Faites de même avec l'autre axe et n'hésitez pas à faire un schéma pour ne pas oublier.

Vous êtes prêt à utiliser le Joystick avec un microcontrôleur type Arduino (cf. article suivant).

jeudi 19 septembre 2013

Récupérer les trames NMEA d'un GPS

Dans cet article, nous allons récupérer les trames NMEA d'un GPS. Par la suite nous les stockerons sur la Raspberry PI afin de les afficher par la suite sur une carte Google Maps.



Matériel utilisé :
- RaspberryPI
- dongle Wifi
- un GPS permettant de récupérer les trames NMEA (Inforad dans un premier temps et GPS Seedstudio par la suite)

Vérifier la réception des trames NMEA

Pour tout savoir sur la norme NMEA.

L'objectif est d'analyser ses trames et de récupérer les informations de base pour placer un Marker sur une carte (latitude et longitude).

Dans un premier temps, j'ai récupéré un "assistant à la conduite" anciennement appelé "détecteur de radar" de marque Inforad. Ces petits appareils permettent de prévenir de la présence d'un radar d'une zone de danger lorsque l'on circule sur une route.
Ces appareils contiennent une base de données de radar, que l'on peut mettre à jour depuis son ordinateur, et se sert de la position GPS pour prévenir des zones à risque. Cela a évité un grand nombre d'amendes et de retraits de points d'accidents sur les routes.

Bref, ces appareils sont très intéressant puisqu'ils transmettent via le port série (port USB) les trames NMEA. Ils ont été remplacés par des modèles connectés ou par des GPS indiquant eux aussi les zones à risque. Si vous avez ce type d'appareil, ressortez le du placard ou demandez à un ami, sinon on peut en trouver pour moins de 10 euros sur les sites de revente.

On peut également trouver certains GPS qui envoient les trames NMEA via le port série. Chercher sur Internet ou sur la documentation du GPS la vitesse de transmission ou Bauds.
Le mien par exemple, et il semble que ce soit généralement le cas transmet à 4800 Bauds.

On va à présent vérifier que le GPS renvoie bien les trames NMEA. Pour cela on va brancher le GPS sur le port USB et vérifier le port COM.
On va utiliser Putty, mais on peut utiliser le logiciel de notre choix qui nous permet de se connecter aux ports COM (screen pour Linux par exemple).

1) Brancher le GPS sur l'ordinateur à l'aide du câble USB
2) Vérifier le numéro du port COM dans la liste des périphériques
3) Ouvrir Putty


4) Sélectionner Serial dans les boutons radios puis saisir le nom du port COM ainsi que la vitesse (ici port COM28 et 4800

5) Cliquer sur Open, un terminal s'ouvre et les lignes NMEA doivent s'afficher



A venir prochainement, la récupération des traces NMEA à partir d'une RaspberryPI et l'affichage sur une carte.

lundi 3 juin 2013

Arduino lent au démarrage et ouverture Outils?

Votre programme Arduino est lent à l'ouverture et lorsque vous ouvrez l'onglet Outil dans le menu.
Essayez de désactiver le Bluetooth de votre PC.
Arduino scan tous les ports COM à l'ouverture du logiciel Arduino et à l'ouverture du menu Outil. Le périphérique Bluetooth utilise des ports COM et ralentit le logiciel Arduino
src : http://arduino.cc/en/Guide/troubleshooting

mardi 28 mai 2013

[RaspberryPI] Commander des prises de courant par radio fréquence via un émetteur 433Mhz

J'ai acheté un pack de prises télécommandées de ce style :

J'avais envie de les commander via une interface Web. Quoi de mieux qu'une RaspberryPI pour ca?
Pour cela j'avais besoin :
- une RaspberryPI
- Un pack de prises télécommandées (voir ci-dessus)
- Un émetteur/récepteur 433Mhz (http://www.evola.fr/product_info.php/kit-transmission-433mhz-compatible-arduino-p-162)

Note importante!

Ces prises que l'on trouve dans le commerce utilise la fréquence 433Mhz pour dialoguer. En fait elle ne dialogue pas vraiment.
La télécommande est codée via 5 interrupteurs que l'on place en position 0 ou 1.
La télécommande est généralement composée de 4 on/off permettant d'allumer ou d'éteindre chaque prise.
Chaque prise est composée de 2 séries d'interrupteurs, le premier correspond au code de la télécommande, et l'autre au numéro de la prise (généralement ce sont des lettres).
En gros lors de l'appui sur un bouton de la télécommande, elle émet un signal composé :
1) du numéro de télécommande
2) du numéro de prise
3) de l'état voulu de la prise

Le code envoyer par chaque bouton est toujours le même.

Pendant ce temps là, les prises écoutes et attendent leur code de déclenchement.

Il est donc très facile de sniffer le code et le renvoyer (Man in the middle) mais heureusement on ne sera pas obligé de sniffer le code puisque des gens ont déjà travaillé dessus.

Nous utiliserons la librairie rc-switch ré-écrite pour la RaspberryPI et qui permet d'émuler, via un émetteur RF 433Mhz, une télécommande. A noter que rc-switch utilise la librairie Wiringpi.
La librairie rc-switch est également disponible pour Arduino et permet d'utiliser le recepteur RF.

Passons à l'installation

A présent nous allons mettre en place notre application.

Paramétrage des prises

1) Dans ce tutoriel, nous allons positionner les interrupteurs de chaque prises sur ON ou 1 (11111). Attention on va faire ca uniquement sur le code correspondant à la télécommande (celui avec 5 interrupteurs).
2) Ensuite on va attribuer une lettre différente pour chaque prise (de A à D)
3) Pour être sûr que cela fonctionne régler la télécommande avec le même code (11111) et brancher chacune des prises. Tester ensuite à l'aide de la télécommande pour voir si chaque prise s'allume et s'éteint.

Branchement du module RF 433Mhz sur la RaspberryPI


1) Relier Vcc > PIN 2 (5V)
2) Relier GND > PIN 6 (GND)
3) Relier output > PIN 11 (GPIO17)

Installer et configurer WiringPI

Installer RC-switch-pi

Tester les interrupteurs

Maintenant que tout est opérationnel, on va allumer une de nos prises.
Pour cela, on va utiliser le fichier send du dossier rc-switch et on va lui passer en paramètres :
1 : le code de la télécommande
2 : le numéro de la prise (1=A ; 2=B ; 3=C ; 4=D)
3 : l'état dans lequel on veut voir la prise (1=allumée ; 0=éteinte)
Exécuter donc la commande suivante (si vous êtes dans le dossier rc-switch) qui va allumer la première prise :
sudo ./send 11111 1 1 
Pour l'éteindre :
sudo ./send 11111 1 0 

Si ca ne fonctionne pas :
1) vérifier que la prise n'est pas à une distance trop éloigner de l'émetteur
2) vérifier les branchements de l'émetteur sur la RaspberryPI
3) reprendre le tuto...

Mettre en place l'interface

Installation du serveur lighttpd

Une fois que ca fonctionne on va pouvoir rendre accessible cette fonctionnalité via une interface Web.
Pour cela on va installer lighttpd qui suffira pour ce dont on a besoin de faire :
sudo apt-get install lighttpd

Création de l'interface

On va utiliser la librairie ainsi qu'un thème JQuery, pour cela configurer et télécharger un thème en suivant ce lien.
Dézipper ce dossier.
Créer un fichier index.php à la racine et y coller le code ci-dessous. Cette page va afficher 4 radio-boutons qui vont permettre d'allumer ou d'éteindre nos 4 interrupteurs.
<!doctype html>
<html lang="us">
<head>
<meta charset="utf-8">
<meta name="viewport" content="initial-scale=1.0">
<title>Domo</title>
<link href="css/ui-darkness/jquery-ui-1.10.3.custom.css" rel="stylesheet">
<script src="js/jquery-1.9.1.js"></script>
<script src="js/jquery-ui-1.10.3.custom.js"></script>
<script>
$(function() {
$( "#radioset1" ).buttonset();
$( "#radioset2" ).buttonset();
$( "#radioset3" ).buttonset();
$( "#radioset4" ).buttonset();

$( ".ui-buttonset" ).change(function(){
var housecode=$(this).children("input[name='housecode']").val();
var numcode = $(this).children("input[name='num']").val();
var state = $(this).children(":checked").val();
console.log(housecode+"  : "+numcode+" : "+state);
$.post("sendVal.php", {housecode:housecode, numcode:numcode, state:state}, function(data){
console.log(data);
});
});
});
</script>
<style>
body{
font: 62.5% "Trebuchet MS", sans-serif;
}
.demoHeaders {
margin-top: 2em;
}
#dialog-link {
padding: .4em 1em .4em 20px;
text-decoration: none;
position: relative;
}
#dialog-link span.ui-icon {
margin: 0 5px 0 0;
position: absolute;
left: .2em;
top: 50%;
margin-top: -8px;
}
#icons {
margin: 0;
padding: 0;
}
#icons li {
margin: 2px;
position: relative;
padding: 4px 0;
cursor: pointer;
float: left;
list-style: none;
}
#icons span.ui-icon {
float: left;
margin: 0 4px;
}
.fakewindowcontain .ui-widget-overlay {
position: absolute;
}
</style>
</head>
<body>
<div id="radioset1" class="ui-buttonset">
Lumière 1 :
<input type="hidden" name="housecode" value="11111"/>
<input type="hidden" name="num" value="1"/>
<input type="radio" id="radio1" name="radio1" class="ui-helper-hidden-accessible" value="1"><label for="radio1" class="ui-button ui-widget ui-state-default ui-button-text-only ui-corner-left" role="button" aria-disabled="false" aria-pressed="false"><span class="ui-button-text">Allumer</span></label>
<input type="radio" id="radio2" name="radio1" checked="checked" class="ui-helper-hidden-accessible" value="0"><label for="radio2" class="ui-button ui-widget ui-state-default ui-button-text-only ui-state-active" role="button" aria-disabled="false" aria-pressed="true"><span class="ui-button-text">Eteindre</span></label>
</div>
<div id="radioset2" class="ui-buttonset">
Lumière 2 : 
<input type="hidden" name="housecode" value="11111"/>
<input type="hidden" name="num" value="2"/>
<input type="radio" id="radio3" name="radio2" class="ui-helper-hidden-accessible" value="1"><label for="radio3" class="ui-button ui-widget ui-state-default ui-button-text-only ui-corner-left" role="button" aria-disabled="false" aria-pressed="false"><span class="ui-button-text">Allumer</span></label>
<input type="radio" id="radio4" name="radio2" checked="checked" class="ui-helper-hidden-accessible" value="0"><label for="radio4" class="ui-button ui-widget ui-state-default ui-button-text-only ui-state-active" role="button" aria-disabled="false" aria-pressed="true"><span class="ui-button-text">Eteindre</span></label>
</div>
<div id="radioset3" class="ui-buttonset">
Lumière 3 : 
<input type="hidden" name="housecode" value="11111"/>
<input type="hidden" name="num" value="3"/>
<input type="radio" id="radio5" name="radio3" class="ui-helper-hidden-accessible" value="1"><label for="radio5" class="ui-button ui-widget ui-state-default ui-button-text-only ui-corner-left" role="button" aria-disabled="false" aria-pressed="false"><span class="ui-button-text">Allumer</span></label>
<input type="radio" id="radio6" name="radio3" checked="checked" class="ui-helper-hidden-accessible" value="0"><label for="radio6" class="ui-button ui-widget ui-state-default ui-button-text-only ui-state-active" role="button" aria-disabled="false" aria-pressed="true"><span class="ui-button-text">Eteindre</span></label>
</div>
<div id="radioset4" class="ui-buttonset">
Lumière 4 : 
<input type="hidden" name="housecode" value="11111"/>
<input type="hidden" name="num" value="4"/>
<input type="radio" id="radio7" name="radio4" class="ui-helper-hidden-accessible" value="1"><label for="radio7" class="ui-button ui-widget ui-state-default ui-button-text-only ui-corner-left" role="button" aria-disabled="false" aria-pressed="false"><span class="ui-button-text">Allumer</span></label>
<input type="radio" id="radio8" name="radio4" checked="checked" class="ui-helper-hidden-accessible" value="0"><label for="radio8" class="ui-button ui-widget ui-state-default ui-button-text-only ui-state-active" role="button" aria-disabled="false" aria-pressed="true"><span class="ui-button-text">Eteindre</span></label>
</div>
</body>
</html>

On va ensuite créer un fichier sendVal.php qui va recevoir les instructions des radio-boutons à envoyer via l'émetteur RF.
<?php
if(isset($_POST)){
if(isset($_POST['housecode']) &&
isset($_POST['numcode']) &&
isset($_POST['state'])){
$housecode = $_POST['housecode'];
$numcode = $_POST['numcode'];
$state = $_POST['state'];
$command = "sudo ./home/pi/rcswitch-pi/send ".$housecode." ".$numcode." ".$state;
system(escapeshellcmd($command));
echo 'ok';
}
}

?>

Envoyer le contenu du dossier dans le dossier /var/www de la RaspberryPI.
Saisir ensuite l'IP de la RaspberryPI dans un navigateur. La page avec les 4 radio-boutons devrait s'afficher.

Tester l'un des radio-boutons. Si cela fonctionne tant mieux! Sinon il faut aller jeter un œil dans les logs.
Personnellement j'avais une erreur d'authentification de l'utilisateur www-data (utilisateur de lighttpd). J'ai réglé cela en ajoutant dans le fichier /etc/sudoers :
www-data ALL=NOPASSWD: ALL

Re-tester, ca devrait fonctionner.