Quelques années après le Raspberry Pi Home Dash Screen j’ai eu envie d’explorer d’autres manières de réaliser un affichage simple sur de petits écrans. Dans cette article, j’explique pas à pas comment réaliser très simplement un écran d’affichage en utilisant un Raspberry Pi et la lib Python PyGame.
L’écran que vous voyez en photo est géré par un simple script en Python qui peut être adapté selon vos besoins.
Matériel utilisé
Cette fois ci, je n’ai utilisé que des éléments officiellement distribué par la fondation Raspberry Pi.
Proposée à l’origine pour créer des jeux vidéos, la lib PyGame vous permet d’afficher très simplement texte, images et autres contenus, sans toutefois nécessiter un gestionnaire de fenêtre. Contrairement au Pi Home Dash screen qui repose sur un ensemble relativement lourd de middleware, l’utilisation de PyGame se suffit à lui même et peut fonctionner directement sur une Raspbian Lite.
Il vous faudra toutefois installer quelques paquets pour Python et Xplanet :
Sur la screenshot ci-dessous, vous voyez plusieurs informations :
La date et l’heure
La température
La terre et la lune
La date et l’heure sont simplement affichée en se basant sur l’heure du système. Inutile ici de chercher quelque chose de compliqué, Python dispose de base de tout ce qu’il faut.
Pour utiliser ce service, vous devez créer un compte gratuit ici :
Rendez vous ensuite dans la section API pour récupérer votre clé API.
OpenWeatherMap fournis un paquet d’informations météorologiques disponibles via une API JSON. Pour récupérer ces informations, rien de plus simple en Python :
Vous pouvez choisir la localité qui vous convient, bien entendu. Ce lien vous permettra de trouver la ville la plus proche de chez vous : https://openweathermap.org/find?q=
Xplanet
L’image de la terre et de la lune sont elles générées par Xplanet, vous savez combien j’affectionne ce soft dont je parle en détails ici : Pi Home Dash Screen – Xplanet
Pour simplifier, j’ai créé deux services, un pour la terre et un pour la lune, qui vont chacun générer une nouvelle image à intervalles réguliers. Le script Python se contera ensuite de rafraîchir les images.
Si dessous, les scripts idoines ainsi que les script systemd permettant de lancer ces sous programmes au démarrage du Pi.
xplanet.conf : Le fichier de configuration de Xplanet
[default]
arc_color=white
arc_thickness=1
bump_scale=3
cloud_gamma=1
cloud_ssec=false
cloud_threshold=90
color={255,255,255}
draw_orbit=false
grid=false
grid1=6
grid2=15
magnify=1
marker_color=red
max_radius_for_label=3
min_radius_for_label=.01
min_radius_for_markers=40
orbit={-.5,.5,2}
orbit_color={255,255,255} # color for the orbit
random_origin=true
random_target=true
shade=30 # 0 = black, 100 = same as dayside
text_color={255,0,0} # color for text (markers & body label)
twilight=6 # blend the day and night images for
# pixels within this many degrees of
# the terminator
[sun]
"Sun"
color={255,255,166}
map=/root/img/sunmap.jpg
max_radius_for_label=0
shade=100
[earth]
"Earth"
color={28, 82, 110}
map=/root/img/land_ocean_ice_2048.jpg
night_map=/root/img/night-dark.jpg
cloud_map=/root/xplanet_clouds.jpg
min_radius_for_label=0
[moon]
"Moon"
color={100, 100, 100}
map=/root/img/moonmap2k.jpg
La manière la plus propre de lancer ce petit script est de laisser le système d’exploitation le gérer comme un service. Sous Raspbian, nous utilisons donc systemd et la commande systemctl comme vu précédemment pour les scripts Xplanet.
MAJ août 2016 : Depuis la parution de cet article en septembre 2014 (bientôt 2 ans Oo), de nombreuses évolutions ont été faites sur les Raspberry Pi et Raspbian. Grâce aux retours d’expériences de plusieurs lecteurs et à leur participation, cet article est aujourd’hui mis à jour Un gros merci à Arnaud (qui se reconnaîtra) qui m’a notamment envoyé de nombreuses informations sur les modifcations relatives à Raspbian Jessie et au RPi3
Vous pouvez notamment télécharger les versions revues et corrigées des scripts PHP par Arnaud, ici : teleinfo.zip
A l’ère de la domotique et des économies d’énergie, le suivi de la consommation d’électricité dans nos maison devient un point incontournable. Détecter les appareils électriques gourmands, optimiser sa consommation en jouant sur les tarifs heures creuses/pleines, opter pour des ampoules à économie d’énergie et couper ses équipements multimédia lorsqu’on ne s’en sert pas : autant de gestes qui prennent sens à partir du moment où l’on peut en mesurer l’effet sur sa facture EDF.
Dans cet article, nous allons explorer une méthode très simple pour collecter et analyser les informations de notre compteur EDF et les représenter sur un graphique. Comme toujours sur magdiblog.fr, nous utiliserons un Raspberry Pi pour construire ce petit système
Téléinfo EDF, qu’est ce que c’est ?
Depuis quelques années, EDF a ajouté à ses compteurs électriques domestiques la possibilité de lire à distance les informations enregistrées (consommation heures creuses/pleines, consommation instantanée, intensité max, etc…). Ceci permet, entre autre, de renvoyer les informations vers votre coffret EDF extérieur afin que les agents EDF puissent effectuer le relevé de consommation (et donc établir une facture) sans avoir à accéder à votre compteur à l’intérieur de votre maison. Les compteurs compatibles disposent de deux bornes I1 et I2, permettant de récupérer directement les informations sur un bus UART-TTL
Pour plus d’informations sur la téléinfo EDF et son mode de fonctionnement, vous pouvez consulter le document « Sorties de télé-information client des appareils de comptage électroniques utilisés par ERDF« , publié par EDF et disponible ici : ERDF-NOI-CPT_02E.pdf
GPIO et optocoupleur
La première étape consiste à créer le petit circuit électronique qui fera l’interface entre le GPIOdu Raspberry Pi et le compteur EDF. Il s’agit simplement de « démoduler » le signal sortant des bornes I1 et I2 du compteur, à l’aide d’un optocoupleur et d’une paire de résistances. Le circuit est ensuite relié a la broche UART du GPIO du Raspberry Pi ce qui nous permettra de récupérer les trames de données du compteur EDF.
Voici un schéma électronique du circuit qui est très répandu sur la toile :
Ce qui nous donne un montage très simple à réaliser :
Voici ce que ça donne avec un petit bout d’epoxy :
Le branchement sur le port GPIO du Pi est également très simple. On utilise l’alimentation 3,3V du GPIO (fil rouge), la masse du GPIO (fil noir) et la broche 15 RXD (fil jaune).
Il ne reste qu’à connecter les deux fils bleus (ou blanc et bleu, que vous pouvez utiliser dans n’importe quel sens) aux bornes I1 et I2 du compteur EDF (généralement en bas à droite) :
Et voilà A ce stade, votre Raspberry Pi est bombardé en continu par les infos envoyées par votre compteur EDF
Récupération des données
MAJ août 2016 : Depuis la parution de Raspbian Jessie :
Dans le fichier /boot/cmdline.txt :
- supprimer la ligne :
console=serial0,115200
- ajouter la ligne :
enable_uart=1
Inutile de modifier le fichier /etc/inittab.
Sur Raspberry Pi3, l’UART PL011 (full UART) du BCM2837 a été ré-alloué au WLAN/BT combo. Et le mini UART est mis à disposition des utilisateurs (sous le nom de /dev/ttyS0).
Il faut donc configurer /dev/ttyS0 (à la place de /dev/ttyAMA0) et remplacer /dev/ttyAMA0 par /dev/ttyS0 à la ligne 10 de teleinfo_func.php. (voir plus bas)
A ce stade, vous devriez avoir un périphérique /dev/ttyAMA0 qui renvoi l’ensemble des données émises par votre compteur EDF.
En faisant un cat sur ce fichier, vous devriez voir défiler vos données de consommation EDF
cat /dev/ttyAMA0
Note : Si vous n’avez que des lignes du type ADCO 012345678945 ?, il se peut que la téléinfo ne soit pas activée sur votre compteur. Il vous suffit normalement de faire une demande à EDF pour l’activer.
Données de la téléinfo EDF
Comme indiqué dans le document « Sorties de télé-information client des appareils de comptage électroniques utilisés par ERDF« , publié par EDF et disponible ici : ERDF-NOI-CPT_02E.pdf, et selon votre type d’abonnement EDF, vous pouvez récupérer les informations suivantes :
ADCO : Identifiant du compteur
OPTARIF : Option tarifaire (type d’abonnement)
ISOUSC : Intensité souscrite
BASE : Index si option = base (en Wh)
HCHC : Index heures creuses si option = heures creuses (en Wh)
HCHP : Index heures pleines si option = heures creuses (en Wh)
EJP HN : Index heures normales si option = EJP (en Wh)
EJP HPM : Index heures de pointe mobile si option = EJP (en Wh)
BBR HC JB : Index heures creuses jours bleus si option = tempo (en Wh)
BBR HP JB : Index heures pleines jours bleus si option = tempo (en Wh)
BBR HC JW : Index heures creuses jours blancs si option = tempo (en Wh)
BBR HC JW : Index heures pleines jours blancs si option = tempo (en Wh)
BBR HC JR : Index heures creuses jours rouges si option = tempo (en Wh)
BBR HP JR : Index heures pleines jours rouges si option = tempo (en Wh)
PEJP : Préavis EJP si option = EJP 30mn avant période EJP
PTEC : Période tarifaire en cours
DEMAIN : Couleur du lendemain si option = tempo
IINST : Intensité instantanée (en ampères)
ADPS : Avertissement de dépassement de puissance souscrite (en ampères)
IMAX : Intensité maximale (en ampères)
PAPP :Puissance apparente (en Volt.ampères)
HHPHC : Groupe horaire si option = heures creuses ou tempo
MOTDETAT : Mot d’état (autocontrôle)
Une trame commence toujours par l’étiquetteADCO et se termine par le MOTDETAT.
Chaque message, ou ligne, d’une trame est formé de la manière suivante :
ETIQUETTEespaceVALEURespaceCHECKSUM
Seules l’ETIQUETTE et la VALEUR nous seront utiles. La CHEKSUM, ou somme de contrôle sert uniquement à vérifier l’intégrité que la trame.
Données utiles
Avant d’aller plus loin, il convient de faire le point sur les données récupérées. AMHA, seules deux informations sont réellement intéressantes à observer :
la puissance instantanée en Watts (permet de voir sa consommation de « courant » au cours de la journée)
la consommation d’électricité en Wh servant d’élément de facturation à EDF (permet de voir sa consommation global par jour/mois/année en fonction des périodes tarifaires)
Petit détail technique, ces informations ne sont pas directement disponibles ; il va falloir les déduire des données remontées par la téléinfo. Et c’est là que j’en profite pour remercier mon cher cousin Vincent pour m’avoir éclairé sur la subtilité de la chose. Merci Vincent
En effet, la téléinfo ne vous montre que la puissance apparente en Volt.Ampère (étiquette PAPP dans la trame). Rien à voir avec la puissance active en Watts ! Non monsieur ! Enfin presque ! Nous connaissons tous cette formule de puissance :
P = U x I (puissance en watt = tension en Volt X intensité en Ampère)
Seulement voilà, cette formule n’est valable qu’en courant continu… En courant alternatif, tel que délivré par EDF/ERDF, il faut multiplier ce résultat par un facteur de puissance appelé cos phi… Le problème, c’est que ce facteur de puissance est variable en fonction des appareils électriques qui consomment du courant dans votre maison… Rapport à un problème de phase d’après les experts… ^^ Pour les plus courageux d’entre vous, je vous conseille cet article qui explique très bien le pourquoi du comment de la chose : http://www.energieplus-lesite.be/index.php?id=11495
M’enfin bref, revenons à notre téléinfo. Nous n’avons donc pas directement la puissance active en Watt, mais, nous avons l’intensité instantanée en Ampère ! Il nous suffira donc de multiplier ce nombre par 230V (ou 220V, ou 240V, selon que vous soyez proche ou non du transformateur) pour avoir une puissance instantanée en Watt Nous aurons ainsi une idée approximative de la puissance instantanée consommée par tous les appareils de notre maison, ce qui nous permettra par exemple de constater que le chauffe eau fonctionne de telle heure à telle heure, que télé éteinte, on consomme 250W de moins, et que « Oh mon Dieu !!! » une plaque de cuisson ça consomme à MOOOOOOOOORRRRRTTT, 6000 W !!!
En ce qui concerne la consommation quotidienne de courant en Wh, nous devrons également ruser car la téléinfo ne donne que le nombre total de Wh consommés depuis l’installation de votre compteur. Pour avoir la consommation sur une journée, il va donc falloir faire la différence entre le nombre total de Wh consommées ce jour et le nombre total de Wh consommés la veille. Rien de bien méchant donc
Voyons maintenant comment procéder pour récupérer et traiter ces données à l’aide de scripts PHP et d’une base de données SQLite. Nous utiliserons ensuite la librairie graphique Google Chart pour tracer de jolies courbes de notre consommation d’électricité
Traitement des données et création d’un graphique de suivi
Le principe général est simple : un script PHP est exécuté à intervalles réguliers (toutes les minutes pour la puissance instantanée, et une fois par jour pour la consommation quotidienne en Wh), récupère les données de la téléinfo puis les stocks dans une base de données SQLite. Dans un second temps, une page web PHP/HTML lit les infos dans la base de données SQLite et affiche les graphiques.
teleinfo_func.php : script PHP qui contient les fonctions nécessaires aux différents scripts.
<?php
$sqlite = 'teleinfo.sqlite';
//
// renvoie une trame teleinfo complete sous forme d'array
//
function getTeleinfo () {
$handle = fopen ('/dev/ttyACM0', "r"); // ouverture du flux
while (fread($handle, 1) != chr(2)); // on attend la fin d'une trame pour commencer a avec la trame suivante
$char = '';
$trame = '';
$datas = '';
while ($char != chr(2)) { // on lit tous les caracteres jusqu'a la fin de la trame
$char = fread($handle, 1);
if ($char != chr(2)){
$trame .= $char;
}
}
fclose ($handle); // on ferme le flux
$trame = chop(substr($trame,1,-1)); // on supprime les caracteres de debut et fin de trame
$messages = explode(chr(10), $trame); // on separe les messages de la trame
foreach ($messages as $key => $message) {
$message = explode (' ', $message, 3); // on separe l'etiquette, la valeur et la somme de controle de chaque message
if(!empty($message[0]) && !empty($message[1])) {
$etiquette = $message[0];
$valeur = $message[1];
$datas[$etiquette] = $valeur; // on stock les etiquettes et les valeurs de l'array datas
}
}
return $datas;
}
//
// enregistre la puissance instantanée en V.A et en W
//
function handlePuissance () {
global $sqlite;
$db = new SQLite3($sqlite);
$db->exec('CREATE TABLE IF NOT EXISTS puissance (timestamp INTEGER, hchp TEXT, va REAL, iinst REAL, watt REAL);'); // cree la table puissance si elle n'existe pas
$trame = getTeleinfo (); // recupere une trame teleinfo
$datas = array();
$datas['timestamp'] = time();
$datas['hchp'] = substr($trame['PTEC'],0,2); // indicateur heure pleine/creuse, on garde seulement les carateres HP (heure pleine) et HC (heure creuse)
$datas['va'] = preg_replace('`^[0]*`','',$trame['PAPP']); // puissance en V.A, on supprime les 0 en debut de chaine
$datas['iinst'] = preg_replace('`^[0]*`','',$trame['IINST']); // intensité instantanée en A, on supprime les 0 en debut de chaine
$datas['watt'] = $datas['iinst']*220; // intensite en A X 220 V
if($db->busyTimeout(5000)){ // stock les donnees
$db->exec("INSERT INTO puissance (timestamp, hchp, va, iinst, watt) VALUES (".$datas['timestamp'].", '".$datas['hchp']."', ".$datas['va'].", ".$datas['iinst'].", ".$datas['watt'].");");
}
return 1;
}
//
// enregistre la consommation en Wh
//
function handleConso () {
global $sqlite;
$db = new SQLite3($sqlite);
$db->exec('CREATE TABLE IF NOT EXISTS conso (timestamp INTEGER, total_hc INTEGER, total_hp INTEGER, daily_hc REAL, daily_hp REAL);'); // cree la table conso si elle n'existe pas
$trame = getTeleinfo (); // recupere une trame teleinfo
$today = strtotime('today 00:00:00');
$yesterday = strtotime("-1 day 00:00:00");
// recupere la conso totale enregistree la veille pour pouvoir calculer la difference et obtenir la conso du jour
if($db->busyTimeout(5000)){
$previous = $db->query("SELECT * FROM conso WHERE timestamp = '".$yesterday."';")->fetchArray(SQLITE3_ASSOC);
}
if(empty($previous)){
$previous = array();
$previous['timestamp'] = $yesterday;
$previous['total_hc'] = 0;
$previous['total_hp'] = 0;
$previous['daily_hc'] = 0;
$previous['daily_hp'] = 0;
}
$datas = array();
$datas['query'] = 'hchp';
$datas['timestamp'] = $today;
$datas['total_hc'] = preg_replace('`^[0]*`','',$trame['HCHC']); // conso total en Wh heure creuse, on supprime les 0 en debut de chaine
$datas['total_hp'] = preg_replace('`^[0]*`','',$trame['HCHP']); // conso total en Wh heure pleine, on supprime les 0 en debut de chaine
if($previous['total_hc'] == 0){
$datas['daily_hc'] = 0;
}
else{
$datas['daily_hc'] = ($datas['total_hc']-$previous['total_hc'])/1000; // conso du jour heure creuse = total aujourd'hui - total hier, on divise par 1000 pour avec un resultat en kWh
}
if($previous['total_hp'] == 0){
$datas['daily_hp'] = 0;
}
else{
$datas['daily_hp'] = ($datas['total_hp']-$previous['total_hp'])/1000; // conso du jour heure pleine = total aujourd'hui - total hier, on divise par 1000 pour avec un resultat en kWh
}
if($db->busyTimeout(5000)){ // stock les donnees
$db->exec("INSERT INTO conso (timestamp, total_hc, total_hp, daily_hc, daily_hp) VALUES (".$datas['timestamp'].", ".$datas['total_hc'].", ".$datas['total_hp'].", ".$datas['daily_hc'].", ".$datas['daily_hp'].");");
}
}
//
// recupere les donnees de puissance des $nb_days derniers jours et les met en forme pour les affichers sur le graphique
//
function getDatasPuissance ($nb_days) {
global $sqlite;
$months = array('01' => 'janv', '02' => 'fev', '03' => 'mars', '04' => 'avril', '05' => 'mai', '06' => 'juin', '07' => 'juil', '08' => 'aout', '09' => 'sept', '10' => 'oct', '11' => 'nov', '12' => 'dec');
$now = time();
$past = strtotime("-$nb_days day", $now);
$db = new SQLite3($sqlite);
$results = $db->query("SELECT * FROM puissance WHERE timestamp > $past ORDER BY timestamp ASC;");
$sums = array();
$days = array();
$datas = array();
while($row = $results->fetchArray(SQLITE3_ASSOC)){
$year = date("Y", $row['timestamp']);
$month = date("n", $row['timestamp']-1);
$day = date("j", $row['timestamp']);
$hour = date("G", $row['timestamp']);
$minute = date("i", $row['timestamp']);
$second = date("s", $row['timestamp']);
$datas[] = "[{v:new Date($year, $month, $day, $hour, $minute, $second), f:'".date("j", $row['timestamp'])." ".$months[date("m", $row['timestamp'])]." ".date("H\hi", $row['timestamp'])."'}, {v:".$row['va'].", f:'".$row['va']." V.A'}, {v:".$row['watt'].", f:'".$row['watt']." kW'}]";
}
return implode(', ', $datas);
}
//
// recupere les donnees de consommation des $nb_days derniers jours et les met en forme pour les affichers sur le graphique
//
function getDatasConso ($nb_days) {
global $sqlite;
$months = array('01' => 'janv', '02' => 'fev', '03' => 'mars', '04' => 'avril', '05' => 'mai', '06' => 'juin', '07' => 'juil', '08' => 'aout', '09' => 'sept', '10' => 'oct', '11' => 'nov', '12' => 'dec');
$now = time();
$past = strtotime("-$nb_days day", $now);
$db = new SQLite3($sqlite);
$results = $db->query("SELECT * FROM conso WHERE timestamp > $past ORDER BY timestamp ASC;");
$datas = array();
while($row = $results->fetchArray(SQLITE3_ASSOC)){
$day = date("j", $row['timestamp'])." ".$months[date("m", $row['timestamp'])];
$datas[] = "['".$day."', {v:".$row['daily_hp'].", f:'".$row['daily_hp']." kWh'}, {v:".$row['daily_hc'].", f:'".$row['daily_hc']." kWh'}]";
}
return implode(', ', $datas);
}
?>
teleinfo_puissance.php : script PHP exécuté toutes les minutes pour enregistrer la puissance instantanée en V.A et en W.
Pour installer et configurer un serveur web Apache et PHP5. Je vous propose de suivre la procédure décrite dans cette article : PiHomeDashScreen – Installation et configuration. Vous pourrez ensuite afficher cette page PHP/HTML dans votre navigateur.
Résultat
Et voici le résultat pour la puissance instantanée en V.A et W :
Et le résultat pour la consommation quotidienne heures pleines/creuses en kWh :
Comme toujours, les idées d’amélioration, les remarques et toutes les questions sont les bienvenues en commentaire de cet article
Dans mon prochain article « RaspberryPi + Razberry + Domoticz : Le combo parfait ! » je vous montrerai comment créer un système domotique complet et à moindre frais pour gérer efficacement votre maison
MàJ : Un micro module USB prêt à l’emploi est disponible ici : http://hallard.me/teleinfo/. Je ne l’ai pas encore tester, mais cela semble être une solution idéale, quoi que beaucoup plus cher qu’un petit optocoupleur
Deux ans après la présentation du projet Pi BOA Drone – Un avion drone autonome longue distance (qui reste d’actualité), force est de constater que les problématiques logistiques et législatives autour d’un tel projet ont largement freiné son avancement.
En effet, outre le fait qu’il est quasiment impossible d’obtenir une autorisation pour faire voler un engin de près de trois mètres d’envergure en toute autonomie, le matériel et les locaux nécessaires à sa construction ne sont, pour le moment, pas à ma portée.
Rassurez vous, le projet n’est pas abandonné, il me faut simplement trouver les bons partenaires et sponsors pour le mener à bien ainsi que de quoi le financer
Un projet intermédiaire
Tout ceci m’amène à vous présenter un nouveau projet, ô combien plus accessible, le Pi BOAt, un drone marin !
Alors oui, hors de question ici de faire un Lille-Metz (quoi que ?!), mais comme vous allez le voir, les problématiques de navigation et de contrôle entre un avion et un bateau sont relativement similaires. Si si !
Sur un bateau comme sur un avion, il faut gérer des moteurs et des ailerons (ou gouvernails), une position, une direction, une vitesse, la télémétrie, etc… La seule différence finalement, outre les questions de flottaison/aéronautique, c’est qu’un bateau navigue dans un plan, en deux dimensions donc, alors qu’un avion évolue dans un espace en trois dimensions. Voyez, c’est tout pareil
De plus, un bateau coûte beaucoup moins cher en crash-test ! Au pire, un bateau, il faudra aller le chercher à la nage, alors qu’un avion ça a tendance à se vautrer lamentablement en éparpillant des morceaux sur cinquante mètres…
Pour finir, personne n’ira m’embêter avec un bateau, la chasse aux sorcières étant focalisée sur les drones volants
Présentation : Pi BOAt, un drone marin
L’objectif principal de ce projet est le même que pour le Pi BOA Drone et l’ensemble des projets présentés sur MagdiBlog : se confronter à différentes problématiques techniques afin d’étendre nos connaissances
L’objectif secondaire de ce projet est de réaliser une plateforme de drone marin qui pourra servir de base pour une multitude de projets.
Je vais découper le projet en lots techniques que je détaillerai dans des articles dédiés au fur et à mesure de mes avancées. De cette manière, nous pourrons étudier les différents sujets un par un et chaque morceau pourra servir indépendamment à d’autres projets.
Voici les lots techniques que j’ai identifié pour le moment :
gestion des moteurs (PWM)
contrôle des gouvernails (servos moteurs)
télémétrie (WiFi ou 433Mhz)
gestion de la caméra embarquée (module pi caméra avec stabilisateur)
position GPS
position dans l’espace (gyroscope, accéléromètre et boussole)
sonde radar (télémètre à ultra-son)
sonde température
architecture logicielle (Python)
IHM de pilotage (web PHP)
construction du navire (en bois)
Un beau programme donc, qui fait intervenir une multitude de technologies
La construction du navire (la coque et la structure) sera la dernière étape de ce projet.
Deux valent mieux qu’un !
En m’imaginant piloter mon bateau sur un grand lac, il me vint une idée, ou plutôt une angoisse : comment récupérer mon bateau s’il ne répond plus ou qu’une panne survient au beau milieu du lac ?
La réponse : faire un deuxième bateau, plus simple, plus petit, qui pourra accompagner le premier.
Nous fabriquerons donc deux bateaux, sur le même modèle, l’un pouvant venir au secours de l’autre en cas de problème. J’imagine déjà un petit système d’aimants à l’avant et l’arrière… que dis-je !? A la proue et à la poupe des deux bateaux
Je le clame haut et fort, le Raspberry Pi est un tueur de cartes SD ! Je l’ai vu de mes propres yeux et de nombreux témoignages l’attestent ! Mais il y a plus grave, mesdames et messieurs les jurés, ce crime abject n’est pas un cas isolé, derrière cette framboise affriandante se cache un véritable tueur en série ! Nous devons stopper cette infamie !
Le drame
Si je mets, aujourd’hui, le Raspberry Pi au banc des accusés, c’est parce que depuis sa sortie j’ai cramé une bonne dizaine de cartes SD, de marques (même les plus réputées) et de tailles différentes. Toutes ont rendu l’âme après quelques mois d’utilisation intensive… Les preuves ne laissent aucune place au doute ; le Raspberry Pi est coupable ! Mais, mais ! Ce n’est pas vraiment de sa faute
Car, voyez-vous, Raspbian, la distribution Linux dédiée au Raspberry Pi, est un système d’exploitation qui, comme tous ses homologues, sollicite énormément la carte SD du Pi (qui joue le rôle de disque dur, rappelons le) ; écrivant et lisant sans vergogne des kilo tonnes de données à un rythme immodéré. Or, une carte SD n’est pas du tout (vraiment pas !!!) taillée pour encaisser ces assauts répétés.
Le nombre de cycles d’écriture étant limité, les jours de votre carte SD sont comptés dès le moment ou vous la branchez sur un Pi. Secteur par secteur, votre carte SD se consume jusqu’à devenir totalement inutilisable.
Le problème ne vient donc pas directement du Pi, mais plutôt de Raspbian. Le Pi étant disculpé, nous allons voir comment modifier légèrement le fonctionnement de Raspbian pour pallier ce problème de sollicitation abusive de la carte SD.
La solution
La méthode est très simple à mettre en oeuvre. Il « suffit » de déporter de la carte SD à la RAM, les répertoires faisant l’objet de nombreuses écritures de la part du système d’exploitation. Ce tour de passe-passe est possible grâce au système de fichier tmpfs (plus d’info sur tmpfs ici : http://doc.ubuntu-fr.org/tmpfs). En gros, il s’agit de créer des « partitions » (notez les guillemets pour les puristes) directement dans la RAM du Pi ; RAM qui elle, est spécialement conçue pour encaisser de nombreux cycles d’écritures
Les répertoires du système Rasbian à « déplacer en RAM » sont essentiellement les répertoires temporaires et les répertoires contenant les logs. Nous allons donc cibler les répertoires systèmes suivant :
/tmp
/var/tmp
/var/log
On pourrait aller chercher d’autres répertoires, mais ces trois là sont les plus critiques.
Alors oui, je ne le précise pas mais cela coule de source, l’ensemble des données présentes dans ces répertoires seront supprimées à chaque reboot du Pi… Ah bah oui ! Donc si vous souhaitez conserver certains fichiers de logs par exemple, pensez à les déplacer avant
Pour déplacer ces répertoires en RAM, il convient d’éditer le fichier /etc/fstab qui gère les points de montages du système. Ajouter les lignes suivantes :
J’attire votre attention sur le paramètre size de chaque ligne, qui limite le volume maximal de données qui pourront être stockées dans chaque répertoire en RAM. Et comme nos Pi ne sont pas généreusement dotés de ce côté là, il faut y aller avec parcimonie ; 10Mo par répertoire sont suffisants dans la plupart des cas
Bien entendu, il conviendra de redémarrer le Pi pour que les modifications soient prises en compte
Voilà pour les répertoires systèmes qui sollicitent le plus la carte SD.
Décliner la solution
Le gros intérêt de cette méthode, c’est que vous pouvez la décliner pour tous les programmes ou opérations qui, d’une part réalisent de nombreuses écritures sur la carte SD et qui d’autre part ne nécessitent pas de conserver des données de manière persistante.
Prenons l’exemple d’un système de vidéo surveillance ou de streaming vidéo. Les images capturées pour être transmises ne nécessitent pas d’être conservées sur la carte SD. Vous pouvez donc créer un sous-répertoire dans le répertoire home de votre utilisateur, pour y stocker temporairement ces fichiers images :
Dans le cas des fichiers de logs, la méthode tmpfs décrite plus haut présente deux gros inconvénients :
Le premier est que vous perdez toute trace des événements système après chaque redémarrage. Si ce n’est pas gênant pour certains projets, ça peut l’être si vous vous servez de votre Pi comme serveur Web par exemple.
Le deuxième est que certains softs (typiquement Apache) créent un sous répertoire dans /var/log pour y stocker ses fichiers de logs. Hors avec tmpfs, le répertoire /var/log monté en RAM est vide à chaque démarrage ; ce qui empêchera Apache par exemple de démarrer correctement…
Rappelons que le problème des fichiers de logs est le nombre important d’écriture sur la carte SD. L’idéale serait donc de pouvoir conserver nos fichiers de logs mais d’en limiter le nombre d’écriture. C’est exactement ce que se propose de faire ramlog : Il stock temporairement les logs en RAM, puis vient les écrire par bloc dans les fichiers sur la carte SD de temps en temps
Merci à Jerry pour l’info
Pour installer ramlog sur nos Pi, rien de plus simple :
Quand j’ai débuté le projet PiHomeDashscreen il y a un peu plus de deux ans (déjà ?!?), j’avais déjà en tête de le relier, un jour, à un système domotique. En effet, ce type d’écran d’information domestique ne présente de réel intérêt que si les données affichées sont utiles au quotidien. Quoi de plus pertinent que des informations concernant la maison, les températures intérieures et extérieures, la consommation électrique, l’état de l’alarme anti intrusion, la vidéo-surveillance etc… ?
Aujourd’hui, nous allons voir comment exploiter les données de température et d’humidité d’une installation domotique à base de Raspberry Pi et Domoticz et les afficher sur notre PiHomeDashScreen. Cette méthode, qui se base sur l’API de Domoticz, est générique et peut s’appliquer à n’importe quel type de données ou module domotique (interrupteurs, sondes météo, capteur de luminosité, chauffage…).
Prérequis
Avant de pouvoir afficher la température et l’humidité de l’intérieur et l’extérieur de votre maison, vous devez au préalable :
Vous pouvez installer le PiHomeDashScreen et votre box Domoticz sur le même Raspberry Pi. Dans ce cas, voici le matériel minimum dont vous aurez besoin :
Raspberry Pi 2 B (je conseille le modèle 2 B, surtout si vous installez tout sur un seul Pi)
Vous pouvez utiliser n’importe quel sonde météo compatible z-wave comme les bien connues Everspring ST814.
Pour ma part j’utilise des sondes de température et d’humidité Oregon Scientific, réputées pour leur fiabilité. Pour pouvoir les faire fonctionner avec votre Pi et Domoticz vous devrez vous équiper en plus du module USB RFXtrx433.
A ce stade, tout devrait être fonctionnel et vous devriez avoir vos sondes de température opérationnelles dans Domoticz. Pour ma part, j’ai bien mes deux sondes Oregon avec la température et l’humidité comme on peut le voir dans la capture d’écran ci-dessous :
Si tout est ok, alors la suite va se révéler très simple En effet, Domoticz propose une API JSON qui permet, entre autres, d’accéder à toutes les données de vos équipements domotique et en particulier vos sondes de température.
Note : Les données renvoyées par l’API de Domoticz peuvent varier d’une sonde à une autre mais de manière générale vous devriez identifier rapidement les informations dont vous avez besoin.
Dans cet exemple, on repère facilement le champ « Data » qui contient à la fois la température en degrés Celsius et le taux d’humidité en pourcentage :
"Data" : "20.2 C, 56 %"
On repère également les champs « Humidity » et « Temp » qui présentent ces mêmes données de manière brut, c’est à dire sans unité (plus facile à traiter par la suite) :
"Humidity" : 56
[...]
"Temp" : 20.20
Maintenant que nous savons comment récupérer et identifier précisément les données qui nous intéressent, il ne nous reste plus qu’à créer un module pour notre PiHomeDashScreen
Code source à implémenter dans le PiHomeDashScreen
Comme pour la plupart des autres modules, il va nous falloir ajouter un conteneur dans la page d’index, puis déclarer les fonctions PHP et JavaScript qui se chargeront de récupérer et d’afficher les informations
C’est parti ! On commence par le fichier index.php dans lequel il faut placer deux conteneurs principaux (intérieur et exterieur) puis deux sous-conteneurs température et humidité :
<div id="inside">
In
<div id="temp_in"></div>
<div id="hum_in"></div>
</div>
<div id="outside">
Out
<div id="temp_out"></div>
<div id="hum_out"></div>
</div>
style.css
On positionne les deux conteneurs principaux sur l’écran et on ajuste le style d’affichage de la température et de l’humidité :
Note : Une actualisation de l’affichage toutes les deux minutes (120000 ms) est largement suffisante. On peut même pousser à dix minutes, les températures ne variants jamais très brutalement.
ajax.php
Comme pour les autres modules, il suffit d’ajouter l’appel à la bonne fonction PHP :
Petite subtilité ici, nous séparons le travail en deux fonctions. La fonction tempAll() appellera la fonction temp() pour chaque sonde et renverra un array contenant l’ensemble des données. En procédant de la sorte, on factorise un peu le code et on rend plus facile l’ajout d’une troisième sonde.
C’est donc la fonction temp() qui se chargera de contacter l’API Domoticz comme expliqué en début d’article. On utilise pour cela cURL qui est un outil permettant de lancer des requêtes HTTP On prendra soin d’adapter les ids des devices/sondes que l’on souhaite atteindre.
Note : Les données renvoyées par l’API de Domoticz sont au format JSON. Il faut donc veiller à décoder ces données en utilisant la fonction json_decode(). Notez également que nous ré-encodons en JSON les données renvoyées par la fonction tempAll() grâce à la fonction json_encode(), afin qu’elles puissent être facilement lues par la fonction JavaScript.
Et voilà le résultat
Le mot de la fin
Comme évoqué plus haut dans l’article, ce principe d’utilisation de l’API Domoticz avec le PiHomeDashScreen peut être décliné pour n’importe quel type de sonde (météo, luminosité, ouverture de porte, état des lumières, système d’alarme…).
Dans cet exemple j’ai utilisé deux sondes de température, mais il est tout à fait possible d’exploiter les données d’autant de sondes et capteurs que vous le souhaitez On pourrait même envisager d’afficher un plan de la maison avec la température de chaque pièce par exemple.
La manière la plus souple pour afficher des données sur un écran est d’utiliser le langage HTML (comme pour les pages web). Pour rendre le tout un peu plus dynamique, nous utiliserons PHP et un peu de JavaScript. Ces technologies et langages sont très répendues (web) et très simples à utiliser.
En résumé, le Pi HomeDashScreen est un navigateur web, qui affiche une page web Le gros avantage de cette solution, c’est que vous pouvez avoir plusieurs écrans dans votre maison qui affichent la même URL. Si cette URL est accessible depuis l’extérieur de votre réseau, vous pouvez afficher votre écran d’information depuis n’importe où
Dans mon cas, le serveur web est installé directement sur le Pi qui est relié à l’écran. Mais vous pouvez très bien vous contenter d’afficher l’URL publiée par un serveur distant
Note : Pour être franc, c’est la partie la plus chi… la moins intéressante ! Si vous savez installer un serveur web et lancer une application au démarrage du système, passez directement à la suite. Notez toutefois que j’explique ici comment lancer une application (Firefox/Chromium), sans gestionnaire de connexion (ou display manager), sans gestionnaire de bureau et avec un gestionnaire de fenêtre minimaliste. Pour avoir passé plusieurs jours à trouver comment faire, je pense que ça peut être utile Rien que l’auto-login en mode console, ça peut servir !
Note : Ce tuto a été mis à jour le 16.03.2015 pour fonctionner facilement avec une installation classique des dernières versions de Raspbian. Un grand merci à chipsetseo et au magazine The MagPi pour les infos
Note 2 : Je précise que le but est ici de ne pas passer par un environnement de bureau (tel que LXDE disponible par défaut sous Raspbian) inutile et lourd pour afficher une page web, mais simplement un gestionnaire de fenêtre (et notamment openbox) qui est nécessaire et suffisant pour l’affichage d’une fenêtre d’un navigateur comme Chromium. Il convient donc de ne pas activer l’interface graphique via l’outil raspi-config ; voire même de la désinstaller totalement en suivant ce tuto : Supprimer les paquets inutiles pour alléger Raspbian
Installation des paquets
Je ne reviens pas sur l’installation de Raspbian sur la carte SD, ce sujet ayant été traité de nombreuses fois, et notamment dans les projets Pi TimeLapse et Pi CarJukeBox. Partons du principe que vous avez un Pi fonctionnel sous Raspbian, configuration réseau effectuée (ethernet ou wifi) et un accès à Internet.
Vous allez avoir besoin de quatres composants clés :
Apache : serveur web, pour assurer la publication du contenu à afficher
PHP : pour pouvoir traiter dynamiquement les données à afficher
Chromium : pour afficher le contenu HTML à l’écran
Openbox : gestionnaire de fenêtre très léger pour gérer l’affichage de Firefox
xinit : permet d’installer tout ce qu’il faut pour le serveur X (qui se charge véritablement d’afficher toutes ces choses à l’écran)
Pour installer ces composants, utilisez la commande suivante :
Le but est qu’à chaque démarrage du Pi, le système lance Firefox en plein écran sur l’URL du contenu que nous souhaitons afficher, tout en masquant le curseur de la souris. Dans mon cas, je mets en veille l’écran à 1h du matin, et je le réveille à 7h30.
Apache
Rien de plus simple car nous pouvons directement utiliser la configuration par défaut ou presque. Le fichier qui nous intéresse est /etc/apache2/sites-enabled/Default. Vous pouvez le vider et remplacer son contenu par :
Cette configuration minimaliste suffira pour ce que nous souhaitons faire. /var/www correspond au répertoire qui contiendra les fichiers à afficher sur l’écran.
Vous pouvez créer un fichier « /var/www/index.html » et y écrire « coucou« . Ouvrez Firefox et allez à l’adresse http://localhost (localhost, désigne la boucle locale, autrement dit, c’est votre machine, home sweet localhost !). Vous devriez voir votre message « coucou »
Lancer Chromium au démarrage sur la bonne URL
Ceci ce fait en trois étapes. Dans un premier temps, il faut s’auto-loguer en tant qu’utilisateur au démarrage du système (dans mon cas, mon nom d’utilisateur est Jarvis. On ne se moque pas ). Une fois logué, l’utilisateur lance une session du gestionnaire de fenêtre Openbox. Lorsqu’Openbox démarre, il lance à son tour Chromium.
Auto-login au démarrage en mode console
Editez le fichier /etc/inittab et remplacez la ligne :
(Remplacez « jarvis » par votre nom d’utilisateur)
Lancer une session Openbox automatiquement
Cela concerne l’utilisateur qui se connecte au démarrage, nous devons donc éditer le fichier /home/jarvis/.bash_profile. Il se peut que ce fichier n’existe pas, vous devrez alors le créer et y inscrire :
startx
Lancer Firefox au démarrage d’Openbox
Très simple, il suffit d’éditer le fichier /home/jarvis/.config/openbox/autostart et d’ajouter en fin de fichier la commande pour lancer Chromium :
chromium -kiosk –incognito
(-kiosk pour lancer en mode plein écran ; –incognito pour que chromium se lance toujours en ignorant la session précédente)
Configuration de Chromium
Nous approchons du but. Il ne reste plus qu’à configurer Firefox pour sa page d’accueil par défaut soit http://localhost. Pour cela, il suffit d’aller dans les préférences de Chromium et de saisir http://localhost dans le champ « page d’accueil ».
Mise en veille à heure fixe
Pour gérer la mise en veille de votre moniteur à heure fixe, vous pouvez utiliser CRON, qui est un planificateur de tâche. En root, tapez crontab -e puis ajouter les deux lignes suivantes :
0 1 * * * su - jarvis -c "xset -display :0 dpms force off" # met le moniteur en veille à 1h du matin
30 7 * * * su - jarvis -c "xset -display :0 dpms force on" #réveille le moniteur à 7h30 du matin
Ceci permet uniquement de mettre en veille le moniteur. Si vous souhaitez éteindre totalement votre Pi, vous devez remplacer les deux lignes ci-dessus par la ligne :
0 1 * * * /sbin/shutdown -h now # éteint le PI à 1h du matin
Ceci aura pour effet d’éteindre proprement votre Pi. Il ne vous reste plus qu’à utiliser un programmateur horraire, pour couper l’alimentation et la rallumer le lendemain matin.
Installation terminée
Si vous avez bien suivi l’ensemble de ce qui est expliqué dans cet article, vous devriez voir votre page d’accueil, qui n’affiche pour le moment que « coucou », à chaque démarrage de votre Pi. A partir de maintenant, nous allons nous concentrer sur les différents modules à afficher C’est la partie la plus sympa
Depuis la naissance de Raspbian, la distribution basée sur Debian et dédiée au Raspberry Pi, son contenu de base n’a cessé d’augmenter. Du coup, après une installation fraîche de Raspbian on se retrouve avec près de 4Go de données, et des kilo tonnes de logiciels et programmes dont on ne se sert pas forcément. Si bien qu’aujourd’hui, il vous faudra utiliser une carte SD de 8Go minimum si vous voulez faire quoi que soit avec une Raspbian… C’est scandaleux Je plaisante bien sûr, je comprends l’intérêt de mettre à disposition un maximum de composants afin de rendre Raspbian la plus complète possible. Cependant, je me suis surpris à faire le ménage en désinstallant un certain nombre de choses après chaque installation de Raspbian…
En effet, dans un certain nombre de cas, et notamment pour monter un serveur ou un système embarqué, nous pouvons supprimer énormément de ces paquets fournis de base avec Raspbian.
Le gros des données et programmes à supprimer gravitent autour de l’interface graphique. En effet, si vous n’avez pas besoin d’un bureau ni d’un gestionnaire de fenêtre, vous pouvez dégager tout ce qui concerne X et KDE, ainsi que les programmes tels que Wolfram et Scratch (qui sont une sorte d’atelier de programmation).
Voici donc en quatre étapes les commandes à exécuter pour soulager vos Raspberry Pi qui tournent sous Raspbian :
2 – Désinstallation des paquets et dépendances qui ne sont plus utilisées
apt-get autoremove -y
3 – Suppression du cache des paquets de apt
apt-get clean
4 – Suppression des fichiers inutiles
ATTENTION : Si vous souhaitez utiliser les composants vidéo du Pi et notamment les outils raspivid ou raspistill, vous ne devez pas supprimer le répertoire /opt/vc. De manière générale, ne supprimer ce répertoire que si vous n’utilisez votre Pi en tant que serveur (LAMP, NAS, FTP,…) sans utiliser de composants propres au Pi. Dans le doute, ne supprimez pas ce répertoire. Si vous l’avez supprimé par erreur, vous pouvez réinstaller son contenu en lançant la commande rpi-update.
Quand j’ai débuté sur le Pi il y a quelques années, la quasi totalité du contenu que je trouvais sur le net était rédigé en anglais. Mais depuis, grâce au travail de quelques français acharnés, vous trouverez énormément d’informations accessibles aux francophones
J’ai donc pris contact avec ces amoureux de la framboise et la plupart d’entre eux ont accepté avec enthousiasme de répondre à quelques questions sur leur travaux, nous permettant de dresser ce portrait du paysage français autour du Raspberry Pi
(L’intégralité des interviews est disponible en fin d’article)
màj 20.05.2015 avec la participation de Benoit, Emmanuel et Vincent de code4pi.fr
Voilà le décor
Une moyenne d’âge de 33 ans avec une fourchette allant de 20 à plus de 60 ans
Je n’ai pas rencontré de blogueuse qui s’intéresse au Pi
Le plus surprenant, au sens agréable du terme, est sans doute de constater que le Pi intéresse toutes les générations. Sa polyvalence et son accessibilité lui permettent effectivement de répondre à toutes les attentes. En revanche, la gent féminine semble complètement désintéressée de la chose… Pourtant c’est bon les framboises
La volonté de partager
Lorsqu’on leur demande quel est l’objectif de leurs blogs, les réponses sont toutes animées par la volonté de partager et transmettre leurs passions et leurs connaissances.
« Sur notre blog, nous partageons notre passion et décrivons des cas pratiques d’utilisation de la Raspberry pour la domotique. » – Mickael de planete-domotique.com
Voici les cinq premières motivations des blogueurs français autour du Pi :
Proposer des tutoriaux
Partage d’expérience
Actualité
Carnet de bord / Mémo
Tests de produits
« Offrir des tutoriels et/ou astuces pour aider les personnes a tirer le meilleur parti du Raspberry. » – Christophe de pihomeserver.fr
C’est ça que je trouve vraiment génial, cette volonté de partager l’information, de transmettre des connaissances, de donner la possibilité aux débutants de découvrir un sujet, et aux initiés d’approfondir des concepts plus poussés. En effet, même si le contenu est majoritairement destiné aux profanes, les gourous de la framboise et les informaticiens et électroniciens chevronnés ne sont pas en reste compte tenu de la richesse de projets proposés ainsi que de la foultitude d’information et d’explications sur des concepts parfois très techniques.
Les Atouts du Pi
Toute la communauté s’accorde à dire qu’un des plus gros atouts du Raspberry Pi est son prix. En effet, pour quelques dizaines d’euros seulement, on peut se doter d’une plateforme totalement opérationnelle et commencer à attaquer n’importe quel sujet.
« Son prix est un atout très important pour pouvoir explorer Linux à moindre coût et sans mobiliser un PC. » – Christophe de christophe.blaess.fr
Je pense effectivement que le faible coût du Pi favorise grandement la création de projets originaux car avec un Pi, les erreurs ne coûtent pas cher. Je veux dire pas là, qu’on ne risque pas grand chose à essayer de mettre en œuvre un projet quelconque car l’investissement de départ est très faible. On n’a pas peur de cramer son Pi en jouant avec le GPIO, ou encore de le perdre en l’accrochant à un ballon stratosphérique
Voici, par ordre d’importance, les atouts du Raspberry Pi pour la communauté de blogueurs que j’ai interrogé :
Prix
Polyvalence
Taille
GPIO
Simplicité
Outre son prix, sa polyvalence est également un des ingrédients majeur du succès du Pi. Les utilisations possibles sont presque infinies (du lecteur multimédia de salon, aux robots, en passant par la domotique et les automates) ce qui lui permet de séduire à la fois les informaticiens et les électroniciens.
« On peut facilement l’utiliser puis le recycler sur un projet où un autre. » – Lorris de place4geek.com
Viennent ensuite sa taille (très compact et facile à manipuler), et sont GPIO qui permet justement de faire le lien entre le monde de l’informatique et le monde réel. Enfin, sa simplicité d’utilisation et la communauté qui le rendent très accessible.
Développer des connaissances multiples
Même si cela n’est pas toujours exprimé clairement, on sent bien que le Pi permet de relier deux mondes : celui l’informatique, abstrait, et celui de l’électronique, plus concret.
« […] c’est fantastique de développer en 100% virtuel pendant des années et de finir par pouvoir impacter de la robotique, de la domotique et autres domaines plus « concrets » en quelques lignes de code […] » – Valentin
« […] je trouve beaucoup plus intéressant de partir sur un Raspberry et d’avoir le confort d’un Linux embarqué que de choisir un développement autour d’un micro contrôleur […] » – Charles
Lorsqu’on se lance dans un projet avec un Pi, on touche forcément, à un moment où à un autre, à plusieurs disciplines. Ainsi, le Raspberry Pi permet de développer ses connaissances en :
Linux
Électronique
Informatique
Bidouille
Serveur
Domotique
Programmation
« Avant tout, il m’a permis de me remettre au bidouillage et à l’électronique. Cela faisait un moment que j’avais envie de faire quelques chose dans ce genre, et quand j’ai eut mon premier raspberry pi, ça a été le déclic : il fallait que je réussisse à utiliser les GPIOs. » – Manuel de manuel-esteban.com
Le Pi permet se plonger dans différents univers et d’aborder des problématiques techniques très variées, ce qui en fait une plateforme d’apprentissage idéale.
« Le Raspberry Pi m’a entre-autre permis d’approfondir et d’acquérir de nouvelles connaissances sur les systèmes Linux. C’est une machine parfaite pour apprendre, vous pouvez tester et mettre en œuvre simplement toutes sortes de réalisations informatiques. » – Régis de windtopik.fr
L’utilisation de Linux est également un point sur lequel on revient souvent.
Je pense que c’est aussi un moyen simple pour les « jeunes » ou étudiant de découvrir autre chose que Windows. – Christophe de pihomeserver.fr
Remerciements
Je tiens à remercier tous ceux qui ont participé à ce petit tour d’horizon du Raspberry Pi à la sauce française, pour leur travail et le temps qu’ils consacrent à partager leurs connaissances d’une part, et pour leur grande sympathie d’autre part. C’est un des aspects de cette communauté que j’apprécie le plus
Notre blog vise à fournir des tutoriels en langue française pour l’utilisation de Raspbian et de la Raspberry Pi en général. Le but est de fournir à la communauté française des tutoriels de qualité, accessibles aux débutants qui apporte tout de même des informations aux plus confirmés, tout en apportant des précisions d’ordre plus historiques et contextuelles sur les technologies.
Combien de Pi possédez vous ?
5 (à nous 3)
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Sa polyvalence.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Améliorer nos connaissances en Linux, en programmation, mettre en place un système de gestion de SMS avec RaspiSMS, installer des serveurs à bas coût, mettre en place de la vidéo-surveillance, etc
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
RaspiSMS, notre plateforme de gestion, d’envoi et de contrôle de SMS par et de la Raspberry Pi.
Elle est assez variée, mais l’essentiel se résume ainsi : Des tests de produits, des actualités sur le high tech / geek / informatique et des tutoriels avec une bonne partie orientée sur le Raspberry Pi en général.
Combien de Pi possédez vous ?
Actuellement j’en ai deux à la maison un modèle B+ et le tout dernier Raspberry Pi 2 sortit en début d’année. J’ai aidé beaucoup d’amis et de proches avec différents projets (enfin surtout pour Openelec) et je pense que j’ai du avoir plus d’une grosse dizaine de Raspberry Pi entre les mains depuis la toute première version.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Pour moi ce serait le rapport performance / prix, c’est vraiment un mini PC très performant qui peux tout faire ou presque. On peut facilement l’utiliser puis le recycler sur un projet où un autre. Le gros avantage du Raspberry Pi c’est aussi que la communauté qui bosse dessus est immense et on trouve maintenant des distributions et des applications pour presque tout.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Plein de choses, j’ai désormais un média center à la maison avec un Raspberry Pi 2 alors qu’avant sa sortie commerciale je pensais encore me monter un PC dans le salon. J’ai pu m’en servir comme VPN, serveur de fichiers, proxy bloqueur de publicité (privoxy), émulateur de jeux (rétropie), mini serveur Minecraft etc… etc…
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Je n’ai pas vraiment fait de gros projet sur le Raspberry Pi pour le moment j’ai surtout utilisé des distributions existantes et installé quelques applicatifs clés en main.
Mais je pense me lancer prochainement dans quelques projets de domotique.
Partager de nouvelles technologies,échanger dans les commentaire avec des passionés, me servir de mémo
Combien de Pi possédez vous ?
Je dois en être à mon 7em
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Les connexions GPIO ! Evidemment le prix, la petite taille et l’os libre aident aussi beaucoup :p
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Le rpi permet aux développeurs d’intéragir enfin sur le réel a travers les pin GPIO, c’est fantastique de développer en 100% virtuel pendant des années et de finir par pouvoir impacter de la robotique, de la domotique et autres domaines plus « concrets » en quelques lignes de code.
Je suppose que l’inverse doit être vrai aussi (permettre aux électronicien d’aborder le dev plus simplement) mais je suis du mauvais coté de la barrière pour l’affirmer.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Le plus gros projet est sans surprise ma plateforme domotique yana (http://idleman.fr/yana/), en ce qui concerne les futurs
projets, il y a tellement de choses à en faire que j’ai du mal a me décider :D, peut être que je me lancerais dans un drone globe trotter a base de rpi, a savoir un drone en autonomie totale (chargeur solaire) capable de faire le tour de france, de prendre quelques photos et de se connecter aux wifi publiques pour tenir un blog de son voyage.
J’y publie essentiellement des articles sur les aspects bas niveaux de Linux, plutôt dans une optique industrielle.
Combien de Pi possédez vous ?
Une bonne vingtaine. Je les utilise entre autres pour présenter des formations sur Linux embarqué et sur la programmation de drivers. Il y a un roulement régulier dans mon stock (usure, casse, fourniture aux clients…).
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Son prix est un atout très important pour pouvoir explorer Linux à moindre coût et sans mobiliser un PC. J’aime bien utiliser le Raspberry Pi comme système de référence en rédigeant des articles ou en animant des formations car chacun peut facilement reproduire ultérieurement les manipulations pour un prix de revient très raisonnable.
J’apprécie également la présence du connecteur P1 qui permet de faire facilement des expériences d’interfaçage avec les GPIO.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?.
J’ai réalisé beaucoup d’expériences sur le temps réel, sur l’optimisation du temps de boot, sur la parallélisation de compilation, sur la communication avec un microcontrôleur, etc. J’ai pu également approfondir certains mécanismes de construction de systèmes embarqués (Buildroot, Yocto) grâce à la simplicité de programmation de sa mémoire flash (tout sur une carte SD, sans nécessiter de sonde Jtag).
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
J’ai réalisé pour plusieurs clients des simulateurs et des outils de tests que j’ai livrés sur des Raspberry Pi en boîtiers, parfois accompagné d’un petit écran tactile.
La vocation de mon blog est principalement de partager avec d’autres personnes certaines de mes expériences dans le domaine informatique. Dans cet optique, le Raspberry-Pi à très vite pris une place prédominante sur mon blog.
Combien de Pi possédez vous ?
Je possède actuellement 3 Raspberry-Pi (2 model B et un model B+). Je risque de me procurer très vite le Raspberry-Pi 2 pour mettre en œuvre des tutoriels un peu plus “poussé” en performance.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Pour moi le principal atout du Raspberry-Pi est sans conteste sa petite taille ! C’est d’ailleurs ce qui m’a fait acquérir mon premier modèle. Je recherchais à l’époque une petite machine peu bruyante pour mettre en place une station de téléchargements. Ensuite j’ai découvert les nombreuses possibilités que procure une telle machine. Notamment en termes d’apprentissage sur linux. Cependant, il faut noter le coût très abordable du Raspberry qui n’est pas négligeable.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Le Raspberry Pi m’a entre-autre permis d’approfondir et d’acquérir de nouvelle connaissance sur les systèmes Linux. C’est une machine parfaite pour apprendre, vous pouvez tester et mettre en œuvre simplement toutes sortes de réalisations informatiques. Au-delà, le Raspberry-Pi m’a permis de partager avec d’autres personnes également intéressé par cette mini-machine.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Pour le moment, je n’ai pas vraiment eu de gros projet sur le Raspberry Pi. Malgré tout, j’ai passé un certain temps à peaufiner des projets comme les différents média-center, la station de téléchargement et la mise en place d’un cloud personnel avec Owncloud. Cela dans le but de rendre mes tutoriels de plus accessible possible.L’un des projets que j’aimerai réaliser dans le futur serait de mettre en place une sorte de tableau de bord avec des leds qui permettent de vérifier le statut de certains matériels informatiques. Le tout associer à un système de type Nagios. Je vais également essayé de continuer de poster des tutoriels accessibles gratuitement au plus grand nombre.
Rendre accessible à tous l’univers du Raspberry Pi.
Combien de Pi possédez vous ?
2, un modèle B et un modèle 2.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Son prix ! $35 pour un ordinateur d’appoint, c’est attractif
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Faire découvrir des distributions Linux à des novices en informatique.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Avec l’arrivée du Raspberry Pi 2 plus véloce, j’ambitionne de l’utiliser comme plateforme d’intégration continue pour mes projets informatiques afin de les construire automatiquement chaque soir depuis ce micro-ordinateur.
Il y a 3 ans, j’ai initier un hacklab dans ma région : http://hacklab.fr/, on a fait beaucoup d’Arduino donc là on va commencer une série d’atelier sur le Raspberry.
Partager des informations, des tutoriels, principalement autour du DIY, d’arduino ou du Raspberry Pi justement
Combien de Pi possédez vous ?
6 ou 7. J’ai un B qui est peut être grillé, qui en tout cas ne fonctionnait pas la dernière fois que je l’ai testé. En gros j’ai 3 ou 4 B, un B+, un A+ et un 2.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Il a pour moi un gros avantage : sa capacité pour un tel prix. Pour un tel prix, on a un mini ordinateur. D’un côté on est heureux d’avoir les GPIOs qui nous permettent de communiquer avec l’environnement physique, d’un autre on a tout de même un ordinateur, avec toute la puissance que cela implique.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Avant tout, il m’a permis de me remettre au bidouillage et à l’électronique. Cela faisait un moment que j’avais envie de faire quelques chose dans ce genre, et quand j’ai eut mon premier raspberry pi, ça a été le déclic : il fallait que je réussisse à utiliser les GPIOs.
Puis de fil en aiguille à faire des projets toujours plus complexes, et retrouver un peu mes bases d’électroniques perdues depuis le collège.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Mon plus gros projet avec un PI est sans aucun doute YDLE. C’est un projet open source et open hardware de domotique, le tout orienté DIY et lowcost pour que chacun puisse se faire sa domotique maison multi protocole. On avance malheureusement par vague, mais le Pi est au coeur du projet.
Après j’ai de nombreux projets autour du Pi dans les tuyaux :
Un robot à base de Pi,
Une borne d’accès à mon fablab en RFID basée sur un Pi
Une caisse enregistreuse RFID basée sur un Pi,
Lire mon withings pulse avec un raspberry pi (pas gagné à première vue) ..
Cahier de brouillon histoire de ne pas oublier des trucs que j’ai mis des jours à trouver.
Combien de Pi possédez vous ?
3
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Appareil au rapport qualité prix imbattable. Consommation électrique faible, nous permettant de le laisser tourner 24/24 à moindre coût (comparer aux vieilles tours que nous avons déjà tous utilisés, y’a pas photo). Un des principaux atout du rapsberry réside dans sa capacité à s’adapter à l’usage que chacun souhaite en faire. Certains le verrons comme une centale domotique à moindre coût, d’autres l’adapterons en homecenter et tout ça grâce à la communauté qui s’est formée autour.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Multi usages et surtout possibilité d’avoir des ports GPIO permettant sans ajout de carte de voir un changement d’état de diodes (je ne parle pas de puissance bien sur). Permet de mieux appréhender les solutions linux, voir la programmation avec scratch (je l’ai découvert lors d’une journée d’échange). Développement très facile d’applications pratiques pour la maison. Mon principal raspberry supporte l’application domoticz. Cette dernière me permet de domotiser ma maison trés simplement (relevé de températures, commande d’éclairage VMC, pompes etc). Le second héberge un serveur Kodi pour gérer mes films et le dernier…il prend cher à longueur de temps car il me sert de test et quoi que l’on puisse en dire, ils sont robustes.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Au départ, j’avais developpé quelques pages web et scripts et par manque de temps, je me suis rabattu sur domoticz. Dans l’année, je pense tester son pendant français jeedom. Dans le cadre de la rénovation de notre maison, je metterai en pratique ta solution homedash screen qui est pour moi la plus aboutie que j’ai eu l’occasion de tester. Aprés il faut avoir du temps a moins d’être un no life mais avec les enfants c’est i m p o s s i b l e
Sur ce site ou je poste maintenant plusieurs fois par semaine après
avoir stoppé pendant quelques mois, j’expose ma vision des choses par
rapport au Raspberry pi et à la technologie en général. J’ai posté
beaucoup de tutoriels pendant les 2 premières années après que le site
ait été créé, mais maintenant je préfère écrire des articles sur des
sujets autres que le Raspberry pi en les liant au Raspberry pi ou encore
simplement poster l’actualité du Raspberry pi en général.
Combien de Pi possédez vous ?
Je possède chez moi un Raspberry pi B+ que j’ai depuis la création du
site et un Raspberry pi 2 que j’ai acheté il y a pas très longtemps.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Son plus gros atout ? Je dirais que c’est ça taille, il est petit et on
peut vraiment l’emmener partout. Si le Raspberry pi n’existerai pas il
faudra pour faire un média center,une caméra de surveillance, un drone…
se trimbaler un gros ordinateur avec une grosse prise d’alimentation (et
encore pour le drone ça ne serait pas vraiment possible), le Raspberry
pi peut être alimenté par microUSB et c’est aussi un grand atout. On
peut facilement y brancher une batterie externe pour le rendre
complètement nomade.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Aucun gros projet pour l’instant, je l’utilise principalement comme un
média center ou pour jouer avec les commandes sur Raspbian.
Offrir des tutoriels et/ou astuces pour aider les personnes a tirer le meilleur parti du Raspberry et occasionnellement de l’arduino.
Combien de Pi possédez vous ?
4 officiels, 1 banana, 1 orange et 1 arietta.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Comment choisir entre taille, performance (c’est relatif bien sur), prix, communauté, politique de la fondation Raspberry Pi, la partie électronique avec les GPIO ? Moi je ne peux pas choisir. Les possibilités larges permettent de toucher un large public à mon avis.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Dans un premier temps revenir dans le monde UNIX ! Je pense que c’est aussi un moyen simple pour les « jeunes » ou étudiant de découvrir autre chose que Windows. Dans un deuxième temps, l’apport est la découverte de l’électronique grâce aux géniallissimes GPIO ! De la LED au GPS, NRF24L01, etc.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Le plus gros projet, l’enregistreur sur ma moto ! Température, vitesse, localisation, inclinaison et branchement sur piles. Le moyen de combiner logiciel et électronique.
La suite : trop de projets qui ne sont pas terminés mais dans les grandes lignes : une station domotique (classique), un graveur laser piloté par le Raspberry. Entre autre !
Électronique mais plus généralement le do it yourself.
Combien de Pi possédez vous ?
En fonctionnement et en « stock », je dirai environ 5-6, de tout modèle (A+, B+, Pi2, …).
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Son prix, je pense que c’est ce qui lui a permis de percer aussi vite, enfin, il faut également mentionner sa simplicité d’utilisation lié à une grande communauté active qui à déblayé la route et porté plein de projet dessus.
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Comme dit plus haut, le Raspberry m’a clairement apporté la facilité de développement / déploiement, pour de petit projet spécifique, je trouve beaucoup plus intéressant de partir sur un Raspberry et d’avoir le confort d’un Linux embarqué que de choisir un développement autour d’un micro controleur (Arduino ou autre) pour un prix finalement très proche, bien entendu, ce choix n’est pas toujours possible…
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
J’ai également développé Bleuette (une présentation sur fait main mag : http://faitmain.org/volume-3/bleuette.html), un robot hexapode, basé au début sur un Arduino, je l’ai ensuite porté sur Raspberry afin de bénéficier d’un confort plus important.
Les futurs projets sont nombreux mais c’est encore un peu tôt pour en parler…
Notre site est une boutique de domotique à la base, nous vendons des
produits de domotique, d’alarme, de confort.
Notre passion pour les cartes embarquées et les possibilités de la
Raspberry nous a immédiatement poussé à revendre ce produit et de
nombreux accessoires.
Sur notre blog, nous partageons notre passion et décrivons des cas
pratiques d’utilisation de la Raspberry pour la domotique, avec le
logiciel Domoticz par exemple qui est l’un des plus puissant actuellement.
Combien de Pi possédez vous ?
A titre personnel, j’en ai 2 (une pour faire des manips sous Domoticz et
un peu de développement) et une seconde pour un serveur PBX Asterisk.
Pour l’entreprise, nous en avons 1 pour faire des tests et le support de
nos clients.
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Son prix bien sûr, mais aussi sa simplicité d’utilisation. Le fait de
pouvoir mettre le système sur une carte SD et ainsi de le dupliquer, de
le partager est tout simplement une révolution au niveau simplicité.
Même quelqu’un qui ne connait rien à Linux peut installer une
distribution en 5 minutes en gravant une carte SD …
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Des minis serveurs à moindre coup. Des petites tâches qui nécessite
d’avoir un serveur allumé en permanence…
J’utilise aussi mon NAS synology pour certaines de ces tâches
Nous travaillons aussi régulièrement avec des Lycées et Collèges qui
l’utilise en cours de technologie. Il est plaisant de voir que par son
prix la carte est accessible au plus grand nombre y compris dans
l’éducation.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Celui qui m’a pris le plus de temps est la configuration de la
distribution PBX, et encore tout n’est pas fonctionnel comme je le
voudrais aujourd’hui…
Parmi les futurs projets, l’amélioration de quelques fonctionnalités
essentielles de Domoticz fait partie des projets que j’aimerais bien
conclure.
Nous avions pris un stagiaire spécialement pour travailler sur ce sujet
l’an dernier. Nous lui avons fait développer plusieurs plugins pour
Domoticz (carte IPX, drivers PLCBUS, drivers MyFox) et aujourd’hui ce
travail n’est pas dans la version officiel de Domoticz (malgré l’accord
du développeur principal) tout simplement car nous n’avons pas le temps
de finaliser l’intégration dans la version actuelle qui a évolué depuis
le début du projet de notre stagiaire ….
Benoit, Emmanuel et Vincent de code4pi.fr (23, 24 et 23 ans)
Quelle est la vocation de votre site/blog ?
Partager autour du Raspberry, de nos différentes expérimentations en fonction de nos compétences.
Combien de Pi possédez vous ?
Benoit : 1x modèle B, 1x modèle A, 2x modèle B rev2, 1x modèle B2 (bientôt un deuxième)
Emmanuel : 2x modèle B rev2, 1x modèle B2 (bientôt un deuxième)
Vincent : 3x modèle B, 1x modèle B2 (bientôt un deuxième)
Pour vous, quel est le plus gros atout du Raspberry Pi ?
Benoit : Prix, taille, interfaces disponibles (GPIO, USB …)
Emmanuel : Son prix et sa taille
Vincent : Prix & taille
Que vous a apporté ou que vous à permis de faire le Raspberry Pi ?
Benoit : Avant le Raspberry Pi, on utilisait régulièrement des anciens PC afin de les recycler en tant que mini serveurs. Néanmoins cette solution n’était pas hyper pratique et elle était quelque peu encombrante. J’ai alors commandé mon premier Raspberry Pi dès sa sortie.
Emmanuel : Benoit avait commandé une des premières versions, puis à force de l’entendre parler bidouille sur son mini-ordinateur je me suis lancé également dans l’aventure de la Framboise.
Vincent : De la même manière qu’Emmanuel, j’ai observé mes deux amis bidouiller une voiture radiocommandée avec Arduino et Raspberry Pi… Et il a fallut que je me procure cette petite carte assez rapidement par la suite, car j’ai été séduit par les possibilités que pouvais offrir le petit ordinateur.
Quel est votre plus gros projet basé sur un Pi, et quels sont vos futurs projets autour du Pi ?
Benoit : Media-center, mini serveur web, de téléchargement. J’ai aussi développé un système de LED couplé à un écran LCD qui s’intègre avec les jeux de la série F1 de Codemaster (https://youtu.be/02iXeilweLQ). Dans un cadre professionnel j’ai aussi été amené à développer différents systèmes embarquées à base de Raspberry Pi, notamment des outils lean (suivi d’avancement de tâches sur un écran), système de diaporama paramétrable, outil d’analyse de données radar …
Emmanuel : En perso j’ai des choses assez classiques : media-center sous XBian et mini-box domotique sous domoticz. Mes futurs projets sont : migration de la box domotique sous Jeedom (avec Razberry Zwave+), contrôleur d’aquarium avec caméra et suivi de température. Cependant un de mes plus gros projet dans le cadre professionnel qui repose sur Raspberry Pi est une solution de monitoring/alerte de chauffage dans une chaufferie collective d’immeuble.
Vincent : Média-center, serveur multi usage (web, git). J’ai également été amené à travailler avec Benoit, dans le contexte professionnel, sur la collecte et le traitement de données radar. Le plus gros projet actuellement achevé est un montage type Ambilight pour mon téléviseur avec projection lumineuse des images passant sur le média center, mais aussi de consoles, lecteurs bluray / dvd, ou tout autre interfaces raccordées au système. Je travail actuellement sur un système à embarquer pour tracer un véhicule avec signal GPS, données collectées sur le véhicule (si celui-ci dispose d’une interfaces ELM327), communication par GSM & 3G.
Alors que le modèle 2 B vient tout juste de sortir avec des gains de performances jusqu’à 6 fois plus rapide, la fondation Raspberry Pi annonce la sortie du modèle C qui explose littéralement tous les records.
On en sait encore très peu sur les dates de disponibilité et les spécifications exactes, mais voici de quoi sera fait ce Pi survitaminé :
Spécifications techniques :
processeur 8-cores (BCM214171)
2GB RAM
Gigabit Ethernet port (il était temps !!!)
port camera 4k/AK
nouvelle puce ATMEGA328P
Sortie video/audio composite qui permet d’avoir soit le son, soit l’image
USB3 (Hallelujah !!!)
Pour le reste, on garde le même gabarit, la même consommation que le modèle 2 B et comme d’habitude, on garde également le même prix (annoncé 35$).
Cadencé à 1,5Ghz, le processeur octo-coeur BCM214171 promet de dépasser toutes les limites actuelles du Pi. Mais pour ma part, c’est l’arrivée du port gigabit Ethernet que est une véritable révolution
Concernant le GPIO, rien d’officiel, mais étant donné ce qu’on peut voir sur les photos, on peut s’attendre à des possibilités démultipliées Les accessoires, cartes d’extensions et boîtiers devraient rester compatibles comme ce fût le cas pour le modèle 2 B.
Ce poisson d’avril étant terminé, vous pouvez vous replonger dans vos projets
Profitez bien du printemps qui arrive et à très bientôt
Pour fêter sa première année d’existence, le site Raspbian-France.fr vous offre 3 Raspberry Pi. Ce site proposant des tutoriels en français autour du Raspberry Pi et de Raspbian connait un succès grandissant depuis sa création et vous propose aujourd’hui de participer à un concours pour gagner l’un des 3 lots suivants :
1er lot : 1 raspberry pi 2 + alimentation + carte MicroSD 16go
2em lot : 1 raspberry pi B+ + alimentation + carte MicroSD 16go
3em lot : 1 raspberry pi A+ + alimentation + carte MicroSD 16go
Pour participer au concours, c’est très simple ! Il vous suffit de retweeter le tweet suivant.
À la fin du concours nous tirerons trois retweet au hasard dont les auteurs recevront un des lots (nous contacterons ces trois gagnants par messages privés Tweeter).
Le concours se déroulera sur 1 semaine à partir de la date anniversaire, soit du 27 mars au 3 avril (inclus).
Je profite de ce message pour vous demander si vous allez y participer, et si vous seriez intéressés par un concours similaire organisé sur MagdiBlog.fr ? Donnez moi vos réponses en commentaire
Qu’il s’agisse de domotique, de vidéo-surveillance ou de simple partage de fichiers, les besoins de se connecter à un équipement se trouvant à l’intérieur de notre maison à travers Internet se multiplient. Bien que ces systèmes soient de plus en plus généralisés et faciles à mettre en place, la question de la sécurité est souvent reléguée au second plan.
Comment s’assurer que personne ne nous espionne avec nos caméras IP installées dans notre salon ? Comment empêcher une personnes curieuse, voire malveillante, de jouer avec notre centrale domotique ?
Dans l’ensemble de mes articles, j’ai toujours insisté sur l’importance de sécuriser ces accès. Aujourd’hui, je vous propose de voir comment créer un point d’accès sécurisé grâce à un Raspberry Pi.
Contexte
Prenons l’exemple d’une caméra IP. Ce type de caméra dispose généralement d’une interface web qui vous permet de la configurer et de visionner les images. Vous vous connectez à cette interface web grâce à un navigateur en vous connectant sur une URL du type http://192.168.0.17:8080. (192.168.0.17 étant l’adresse IP de votre caméra sur le réseau interne à votre maison).
Cela signifie que le service (c’est à dire le logiciel) qui vous permet d’interagir avec votre caméra, est disponible sur le port 8080/TCP. Si vous voulez pouvoir accéder à votre caméra depuis l’extérieur de votre maison, c’est à dire en passant par Internet, vous allez devoir configurer votre box, modem ou routeur, pour autoriser les flux sur ce même port 8080/TCP à destination de l’adresse IP interne de votre caméra. Votre box agit alors comme un « aiguilleur », qui lorsqu’il recevra une connexion depuis l’extérieur de votre réseau sur le port 8080/TCP redirigera le flux vers votre caméra IP.
Le hic, c’est que cela fonctionnera avec vous, mais aussi avec tout le reste de la planète ! N’importe qui connecté à internet peut se connecter à votre caméra !
Vous me direz : « Oui, mais il y a un mot de passe !« . En effet, il reste à trouver le mot de passe (si vous en avez un, et qu’il est suffisamment compliqué) pour pouvoir vous espionnez. Gardez cependant à l’esprit que de l’extérieur (comprenez depuis Internet), si vous pouvez vous connecter à votre caméra/box domotique/serveur de fichiers, alors tout le monde peut s’y connecter également.
Notions et principes de base en sécurité informatique
Pour sécuriser l’accès à un service (logiciel) à travers un réseau tel qu’Internet, il y a trois choses à mettre en place :
protéger l’accès grâce à un mot de passe : réserver l’accès à ceux qui connaissent le mot de passe
vérifier l’identité de la personne qui se connecte : s’assurer que la personne qui tente de se connecter est bien une personne autorisée
chiffrer les informations et les données lorsqu’elles transitent sur le réseau : empêcher que quelqu’un intercepte votre mot de passe et vos données personnelles
En effet, un mot de passe seul ne suffit pas car il peut être découvert ou volé. Et si vous pensez que personne ne peut vous voler votre mot de passe, détrompez vous ! La chose à garder en tête, c’est que lorsque vous êtes à l’extérieur de votre maison, vous utilisez un réseau que vous ne maîtrisez pas (WiFi publique, réseau 3G/4G de votre opérateur mobile, réseau de votre entreprise, etc…). Sur ces réseaux, vous n’avez absolument aucune garantie que personne n’observe ce que vous faites. On peut même dire que vous avez la certitude que vos données peuvent être lues par quelqu’un. Pour résumer : Si vous saisissez votre mot de passe quelque part, il sera visible par les équipements du réseau que vous utilisez.
Si vous n’êtes toujours pas convaincu par cette fragilité, je vous conseille vivement de lire le dossier dédié à ce sujet dans le dernier Canard PC Hardware (n° 23) http://www.canardpc.com/news-53226-cpc_hardware_n__23_est_disponible__.html. Vous verrez avec quelle facilité il est possible de récupérer vos mots de passe.
Comment faire pour se protéger ?
La solution pour éviter que votre mot de passe soit intercepté, est de chiffrer (comprenez crypter) les flux entre vous (votre navigateur, votre smartphone), et l’appareil auquel vous vous connectez (caméra ip, box domotique,…). Nous verrons plus loin comment mettre cela en place.
Enfin, pour nous assurer que notre accès est sécurisé, il convient de mettre en place un « contrôle d’identité« . Dans la vraie vie, pour contrôler que vous êtes bien la personne que vous prétendez être, on vous demande votre Carte Nationale d’Identité. Cette carte d’identité garantie que vous êtes bien vous en s’appuyant sur deux choses : la première c’est que vous la possédez (vous prouvez votre identité en étant détenteur de votre carte) ; la seconde est qu’elle a été faite par une autorité suprême, à savoir l’Etat, qui a préalablement réalisé les contrôles nécessaires avant de vous délivrer votre carte d’identité qui indique que vous êtes vous (Une carte réalisée par le boulanger du coin n’aurait pas la même authenticité). Pour résumer : Vous possédez une carte d’identité, et c’est l’Etat (entité de confiance) qui atteste que c’est bien vous. Vous pouvez donc récupérer votre colis à La Poste, puisque c’est l’Etat qui garantie que vous êtes bien vous. Retenez bien ce principe, car il est très important pour comprendre la suite.
Dans le monde de la sécurité, on parle d’authentification forte lorsqu’il est nécessaire de présenter au moins deux choses pour vous connecter : quelque chose que vous connaissez (un mot de passe), et quelque chose que vous possédez (une carte, un badge, un certificat) ou que vous êtes (une empreinte digitale, une empreinte vocale…).
Certificats
En informatique, pour désigner l’équivalent d’une carte d’identité, on parle de certificat. Lorsque vous allez sur un site internet utilisant un certificat, vous voyez généralement un petit cadenas dans la barre d’adresse et l’URL commence par https. En cliquant sur le cadenas, on peut afficher le certificat utilisé par le site :
Nous voyons que ce certificat a été émis par VeriSign qui est une autorité de certification reconnue dans le monde de l’Internet (à l’instar de l’Etat pour nos CNI). Ce certificat à été émis pour le site www.paypal.com de la société PayPal. Le site de Paypal présente donc un certificat qui atteste de son identité, et que cette identité à été vérifiée par VeriSign. Nous avons donc l’assurance qu’il s’agit bien du site de PayPal
Il s’agit là d’un certificat serveur, pour que les clients puissent vérifier qu’il s’agit bien d’un serveur légitime. Pour notre passerelle sécurisée, nous ajouterons un certificat client, pour que le serveur puisse valider que le client est bien légitime également.
A retenir
Pour garantir la sécurité d’un accès au travers d’un réseau il est nécessaire vérifier que vous êtes vous, que vous connaissez le mot de passe, et que ces données transitent chiffrées (cryptées) sur le réseau.
Pardonnez la longueur de ces explications, mais il nécessaire de bien comprendre les tenants et les aboutissants de ces éléments pour mettre en place un système fiable et sécurisé. Ceci étant dit, passons au choses sérieuses en réalisant un système qui mette tout ceci en œuvre. Procédons
Le matériel nécessaire
Rien de bien compliqué, un pack de base (Raspberry Pi, alimentation, carte SD et boitier) suffit. Je conseille toutefois le choix d’un modèle équipé d’un port Ethernet.
Le Raspberry Pi 2 étant vendu au même prix que le B+, ne nous en privons pas !
Construction de la passerelle sécurisée : schéma global
Le principe global est de mettre la passerelle sécurisée dans une DMZ (zone démilitarisée) et de bloquer les accès directs grâce au firewall (pare-feu) de la box Internet (ou du modem/routeur). De cette manière, tous les flux provenant de l’extérieur (Internet) sont redirigés vers la passerelle qui se charge de chiffrer les flux et de vérifier l’identité du visiteur. Ces deux étapes s’appuient sur des certificats. Si tout est ok, la passerelle redirige à son tour les flux vers l’équipement ciblé (On peut imaginer plusieurs équipement, caméras, une box domotique, un serveur de fichier,… ). L’authentification par mot de passe est assuré par l’équipement lui même en dernier ressort.
Note : Si votre box Internet ne permet pas de créer une DMZ, vous pouvez vous contenter de placer la passerelle directement dans votre réseau local. Il s’agira alors de configurer le firewall de la box pour rediriger tous les flux externes vers la passerelle.
Installation et configuration
Dans un premier tant il convient d’installer une Raspbian en bonne et due forme. Une fois démarré et la configuration de la carte réseau effectuée, nous aurons besoin d’installer Apache.
apt-get install apache2
Création des certificats
Nous allons donc créer un certificat serveur, et un certificat client (notez que vous pouvez créer autant de certificats client que vous le souhaitez, pour plusieurs personnes par exemple). Pour que ces certificats soient valides, nous devons les faire signer par une autorité de certification qui en attestera l’authenticité. Vous pouvez trouver ces services chez de nombreux fournisseurs reconnus, mais cela à un prix. Nous allons donc créer notre propre autorité de certification. Notez que cela n’est pertinent uniquement parce que travaillons sur nos environnements personnels, car l’autorité de certification que nous allons créer ne sera reconnue que par nous même.
L’outil qui permet de faire cela est openssl. Il est installé de base sur Raspbian.
Création de l’autorité de certification ou CA
Créez un fichier openssl.cnf et placez y cette configuration :
Ceci va générer deux fichiers ca.cer le certificat de l’autorité de certification et ca.key la clé qui sert au chiffrement du certificat.
Création du certificat serveur
Créez dans un premier temps une nouvelle clé :
openssl genrsa -out server.key 2048
Puis créez une CSR (Certificat Signing Request) ou une demande de signature de certificat (c’est l’équivalent du formulaire que vous remplissez en mairie pour faire votre carte d’identité) :
Vous devrez saisir certains paramètres dont le Common Name qui doit correspondre au nom de votre serveur (ou le nom de domaine que vous utiliserez pour vous y connecter).
Enfin, signez la CSR avec le certificat de l’autorité de certification pour obtenir votre certificat serveur :
Trois fichiers seront générés, server.req qui est la CSR et que vous pouvez supprimer, ainsi que server.cer et server.key, respectivement le certificat et la clé du certificat.
Création du certificat client
Comme pour le certificat serveur, il faut commencer par générer une nouvelle clé :
Note : si vous créez plusieurs certificats, incrémentez le numéro de série qui est ici de 101 et qui était de 100 pour le certificat serveur.
Pour que vous puissiez installer votre certificat client dans votre navigateur internet ou votre smartphone, il convient de le convertir au format pkcs12. Le fichier pkcs12 contient à la fois la clé et le certificat :
Nous obtenons ainsi le fichier client.p12 qui contient le certificat client. Vous devez installer ce fichier dans votre smartphone en vous l’envoyant par mail, ou dans votre navigateur sur votre PC en passant par les paramètres avancés.
Pour aller plus loin, nous pourrions créer une CRL ou liste de « révocation » ; il s’agit d’une liste dans laquelle est inscrit tous les certificats que nous souhaitons interdire. Si par exemple vous vous faites voler votre smartphone, vous pouvez ajouter le certificat qui était installé sur votre smartphone à cette liste de révocation pour en interdire l’accès. Vous obtiendrez plus d’information sur les certificats et les listes de révocation en suivant ce lien.
Apache et reverse-proxy
Il s’agit ici de mettre en place un proxy, ou plus précisément, un reverse proxy. Sa fonction première est de gérer l’aiguillage des flux vers la caméra ou la box domotique par exemple. En parallèle il assurera le chiffrement du flux ainsi que la vérification du certificat client (la carte d’identité de l’utilisateur).
Editez le fichier /etc/apache2/site-enabled/000-default et remplacez son contenu par la configuration suivante en remplaçant le chemin vers les certificats du serveur et de la CA :
<VirtualHost *:443>
SSLEngine On # activation https
SSLCertificateFile /chemin/server.cer # certificat serveur
SSLCertificateKeyFile /chemin/server.key # clé du serveur
SSLVerifyClient require # force le serveur à vérifier le certificat client
SSLVerifyDepth 1 # le certificat client doit être signé par la même autorité de certification
SSLCACertificateFile /chemin/ca.cer # certificat de l'autorité de certification
ProxyRequests Off # désactive les requêtes proxy
# redirige camera1 sur l'adresse IP et le port de la caméra 1
ProxyPass /camera1/ http://192.168.0.17:8080/
ProxyPassReverse /camera1/ http://192.168.100.17:8080/
# redirige camera2 sur l'adresse IP de le port de la camera 2
ProxyPass /camera2/ http://192.168.0.18:8080/
ProxyPassReverse /camera2/ http://192.168.0.18:8080/
<Proxy *>
Order allow,deny
Deny from all
allow from all
</Proxy>
LogLevel warn
ErrorLog ${APACHE_LOG_DIR}/rproxy_error.log
CustomLog ${APACHE_LOG_DIR}/rproxy_access.log combined
</VirtualHost>
Firewall
Puisque nous sommes vigilants, nous allons configurer des règles firewall sur notre passerelle sécurisée pour nous assurer que seul le port 433/TCP soit accessible de l’extérieur. Nous utiliserons pour cela iptables qui est installé de base sur Raspbian.
Créez le fichier /etc/init.d/firewall.sh :
#! /bin/bash
### BEGIN INIT INFO
# Provides: firewall
# Required-Start:
# Required-Stop:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Gateway firewall script
# Description: Enable service provided by daemon.
### END INIT INFO
tables_start()
{
iptables -N INPUT_LOG_ACCEPT
iptables -A INPUT_LOG_ACCEPT -j LOG --log-prefix "INPUT_ACCEPT -> "
iptables -A INPUT_LOG_ACCEPT -j ACCEPT
iptables -N INPUT_LOG_DROP
iptables -A INPUT_LOG_DROP -j LOG --log-prefix "INPUT_DROP -> "
iptables -A INPUT_LOG_DROP -j DROP
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -s 192.168.0.0/24 -j ACCEPT # accepte toutes les connexions en provenance du réseau local
iptables -A INPUT -p tcp --dport 433 -j INPUT_LOG_ACCEPT # on n'accepte que les connexions sur les port 433/TCP depuis l'extérieur
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m state --state NEW,INVALID -j INPUT_LOG_DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -j ACCEPT
}
tables_clear()
{
iptables -F
iptables -t nat -F
iptables -X
iptables -t nat -X
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
}
tables_stop()
{
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -j REJECT
iptables -A OUTPUT -j REJECT
iptables -A FORWARD -j REJECT
}
tables_usage()
{
echo "usage: $0 [ start | stop | clear ]"
}
case "$1" in
stop)
echo " Stoping firewall ..."
tables_clear
tables_stop
exit 0
;;
clear)
tables_clear
exit 0
;;
start)
echo " Starting firewall ..."
tables_clear
tables_start
exit 0
;;
-h|--help)
tables_usage
exit 0
;;
*)
tables_clear
tables_start
exit 0
;;
esac
exit 1
Modifiez les droits d’exécution de ce script, puis lancez le automatiquement au démarrage du système :
chmod 755 /etc/init.d/firewall.sh
cd /etc/init.d
update-rc.d firewall.sh defaults
Redémarrez votre Pi, tout est prêt
Le mot de la fin
Il est difficile de proposer une solution « clé en main » pour ce type de système car il faut l’adapter à son réseau et à ses besoins. Dans tout les cas, le plus important à retenir est le principe de centraliser tous les accès sur une passerelle sécurisée avec une authentification forte et un chiffrement des flux.
La sécurité informatique est un sujet très vaste et complexe qui fait intervenir de nombreuses technologies et une multitude de concepts. J’espère vous avoir permis de mettre un pied dedans en vous aidant à protéger l’accès à vos équipements.
Dans cet article j’ai pris l’exemple d’une caméra IP, car c’est un exemple « choquant » en terme de sécurité (on peut être espionné à l’intérieur de chez soit), mais cette passerelle sécurisée peut être utilisé pour tout type d’équipement et projet comme par exemple :
Le module Raspberry Pi Camera (et la version sans filtre IR, le module NoIR) sont de petits circuits (2,5cm x 2,5cm) dotés d’un capteur photo de 2592 x 1944 pixels capable d’enregistrer en 1080p à 30 images par secondes (ou 60 fps en 720p). Ce module se branche directement sur le port CSI du Pi prévu à cet effet.
Que ce soit pour un système de vidéo surveillance ou pour le pilotage d’un robot à distance, il faut pouvoir récupérer le flux vidéo et le diffuser à travers le réseau (streaming). Nous allons voir dans cet article 5 méthodes pour diffuser le flux vidéo d’un module Raspberry Pi Camera, plus ou moins efficacement.
Introduction et matériel utilisé
Le module Raspberry Pi Camera étant branché directement sur un Raspberry Pi, si vous voulez pouvoir voir les images capturées depuis un autre endroit qu’un écran branché sur ce même Pi, vous allez devoir envoyer ces images à travers le réseau. De nombreuses utilisations sont possibles :
la caméra de surveillance que l’on souhaite observer depuis son smartphone quand on part en vacance
le robot que l’on souhaite piloter à distance depuis un ordinateur de contrôle
filmer et diffuser des images en direct à travers internet
etc…
Petit bémol sur la notion de « streaming » vidéo : En principe, lorsqu’on parle de streaming vidéo, il s’agit bien d’un flux vidéo diffusé en direct. Comme nous allons le voir plus loin dans cet article, cette méthode consomme énormément de ressources (notamment en terme de bande passante), et dans de nombreux cas, il sera plus judicieux de diffuser une « suite d’images » à intervalles réguliers.
Le matériel
Pour l’ensemble des méthodes exposées dans cet article, nous utiliserons le matériel et le montage suivant :
On installe une Raspbian, tout ce qu’il y a de plus standard, on se connecte à son réseau WiFi et on active le module caméra grâce à l’outil raspi-config.
Voyons maintenant comment diffuser les images sur le réseau.
Méthode 1 : Netcat et Mplayer
C’est la méthode la plus simple et la plus directe. Il s’agit simplement de rediriger le flux capturé par la commande raspivid dans netcat, puis de récupérer ce flux et l’injecter en entrée dans le lecteur vidéo Mplayer. L’inconvénient de cette méthode est que le flux vidéo n’est visible que depuis un seul PC distant.
Depuis un PC sous Linux exécutez dans un premier temps la commande suivante (après avoir installé mplayer si besoin) :
Cette commande ordonne à nc (netcat) d’écouter sur le port 5001 et redirige ce qui arrive dans le lecteur vidéo Mplayer en prévoyant un cache de 1024 Ko pour 10 images par secondes.
Puis, sur le Pi, il suffit d’exécuter raspivid et de rediriger la sortie vers l’adresse IP de notre PC client en utilisant netcat :
On indique ainsi à raspivid de capturer des images en 1280×720 pixels et de les envoyer à netcat.
Simple et efficace, une fenêtre Mplayer s’ouvre automatiquement sur le PC client avec les images en direct. On notera toutefois une forte latence qui peut varier de 3 à 15 secondes en fonction de la qualité et du nombre d’images transmisses et de la qualité du lien WiFi.
Note : Un test réalisé sur un Raspberry Pi B, branché en Ethernet, permet de réduire la latence à environ une seconde.
Si vous souhaitez enregistrer le flux vidéo dans un fichier sur le PC client, il suffit de modifier la première commande de cette manière :
Cette méthode, relativement simple à mettre en place, souffre d’une très forte latence. Toutefois, et contrairement à la première méthode, le flux vidéo est visible depuis plusieurs postes clients.
Sur le Pi, il suffit d’installer VLC :
apt-get install vlc
Puis de rediriger la sortie de la commande raspivid (comme dans la méthode 1) vers VLC en exécutant la commande suivante :
Cette méthode est à privilégier si vous souhaitez diffuser votre flux vidéo à plusieurs personnes sur internet par exemple, et que la latence n’est pas un problème.
Méthode 3 : streaming de Pi à Pi avec OMXplayer
Les méthodes 1 et 2 permettent de diffuser le flux vidéo à destination d’un ordinateur distant. Si vous souhaitez capturer un flux vidéo depuis un Pi pour l’observer depuis un autre Pi branché à un écran, il convient d’utiliser le lecteur OMXplayer.
Cette méthode est un peu plus complexe à mettre en oeuvre mais permet plus de souplesse quant à l’usage que l’on souhaite en faire. Depuis le Pi équipé du module caméra, nous allons procéder exactement comme pour la méthode 1, en redirigeant la sortie de la commande raspivid dans netcat. Puis, sur le Pi branché à l’écran de visionnage, nous allons dans un premier temps récupérer le flux netcat pour l’enregistrer dans un fichier et le lire, dans un deuxième temps, avec OMXplayer.
Sur le Pi de visionnage, créez d’abord un fichier de type fifo :
mkfifo /dev/shm/video.fifo
Deux points très important à comprendre dans cette commande :
/dev/shm : ce point montage fonctionne comme un disque dur mais aucune donnée ne sera stockée sur le disque dur en lui même ; tout sera géré en mémoire vive. C’est parfait pour y placer un fichier vidéo tampon.
fichier de type .fifo : les fichiers de type fifo fonctionnent comme les fichiers standards, mais se comportent comme des « pipes », ce qui permet au système d’y stocker des données sans passer par le système de fichier. Encore une fois, parfait pour y placer un fichier vidéo tampon
Le fichier tampon étant prêt, il faut maintenant le remplir. Côté Pi de visionnage, mettez netcat en écoute en redirigeant la sortie vers le fichier tampon :
nc -l -p 5001 > /dev/shm/video.fifo
Puis côté Pi caméra, envoyez le flux vidéo à travers netcat comme dans la méthode 1 :
De retour sur le Pi de visionnage, il suffit de dire à OMXplayer de lire le fichier tampon :
omxplayer /dev/shm/video.fifo
Cette méthode n’offre pas une latence exemplaire, mais permet de transmettre un flux vidéo de Pi à Pi. Idéal par exemple pour créer un portier vidéo, avec un Pi qui film et un Pi qui affiche la vidéo, les deux Pi étant reliés par WiFi
Méthode 4 : mjpg-streamer
A partir de là, on sort du streaming vidéo pur et dur puisqu’il s’agit, avec le mjpeg, de transmettre et d’afficher une suite de photos les unes après les autres. Le résultat est beaucoup moins fluide puisqu’on ne pourra espérer afficher que 5 à 10 images par seconde maximum (contre 10 à 30 images par secondes pour les méthodes précédentes), mais nous pourrons exploiter les images beaucoup plus simplement en les affichant dans une page web, ou sur un écran comme le PiHomeDashScreen par exemple. Si vous disposez d’un NAS Synology, ou d’un système sachant gérer des caméras IPs, vous pourrez également exploiter la caméra du Pi grâce à cette méthode.
Par défaut, mjpg-streamer lancera un serveur web sur le port 8080/TCP auquel vous pouvez accéder avec un navigateur en utilisant l’adresse : http://adresse_du_pi:8080
Vous devriez voir l’interface de démonstration de mjpg-streamer :
Les deux options les plus intéressantes sont JavaScript et Stream. Ces deux méthodes vous permettrons de récupérer les images pour les afficher dans une page web, ou sur le PiHomeDashScreen comme vous pouvez le voir dans la photo si dessous :
Pour réaliser cela, j’ai simplement placé le code suivant dans le fichier index.php du PiHomeDashScreen (consulter les articles de ce projet pour en savoir plus).
<div id="webcam"><img src="http://adresse_ip_du_pi:8080/?action=snapshot" /></div>
<script type="text/javascript">
var imageNr = 0;
var finished = new Array();
var paused = false;
function createImageLayer() {
var img = new Image();
img.style.position = "absolute";
img.style.zIndex = -1;
img.onload = imageOnload;
img.onclick = imageOnclick;
img.src = "http://adresse_ip_du_pi:8080/?action=snapshot&n=" + (++imageNr);
var webcam = document.getElementById("webcam");
webcam.insertBefore(img, webcam.firstChild);
}
function imageOnload() {
this.style.zIndex = imageNr; // Image finished, bring to front!
while (1 < finished.length) {
var del = finished.shift(); // Delete old image(s) from document
del.parentNode.removeChild(del);
}
finished.push(this);
if (!paused) createImageLayer();
}
</script>
C’est de loin la méthode que je recommande car elle permet de diffuser les images à plusieurs clients en même temps tout en conservant une latence acceptable pour peu que l’on se contente d’une image de qualité moyenne.
Méthode 5 : Serveur Web
Cette méthode consiste à capturer des images à intervalles régulier avec la commande raspistill, puis à les diffuser grâce à un serveur web Apache. C’est la méthode que j’ai utilisé pour réaliser ce Système de vidéo-surveillance abordable avec des Raspberry Pi.
Cette méthode est très proche, fonctionnellement, de mjpg-streamer. Je songe d’ailleurs à refondre mon système de vidéo surveillance en utilisant mjpg-streamer.
Les méthodes de streaming vidéo pur (méthode 1 à 3) permettent un affichage fluide en sacrifiant la réactivité, ce qui rend cette option inutilisable pour le pilotage d’un robot par exemple.
Les méthodes utilisant une suite d’images sur le principe du mjpeg (méthode 4 et 5) permettent une plus grande souplesse dans l’exploitation des images et offrent globalement une meilleure latence (car moins d’images à traiter et à faire transiter par le réseau). Personnellement, j’utilise la méthode 4 avec mjpg-streamer pour la quasi totalité de mes projets actuels. C’est une méthode très polyvalente, simple à mettre en place et peu gourmande en ressource pour le Pi.
Quelque soit la méthode utilisée, le vrai problème reste la bande passante. Que ce soit en 3G, en Wifi ou même en Ethernet, la vitesse du réseau sera limitante pour la transmission d’images.
Vous trouverez sur le net beaucoup d’articles qui expliquent comment mettre en oeuvre le logiciel Motion sur un Raspberry Pi. Je conseille cette approche uniquement si vous souhaitez faire de la détection de mouvement car Motion est fait pour cela à la base. Même si Motion utilise le même principe du mjpeg que dans les méthodes 4 et 5, il est très gourmand en ressources pour un Pi et offrira moins de souplesse que mjpg-streamer.
Reste une méthode que je n’ai pas encore essayé à ce jour mais qui semble être intéressante car « prête à l’emploi » pour un Pi : http://elinux.org/RPi-Cam-Web-Interface.
Je vous invite à partager vos expériences sur ce sujet, notamment pour savoir si vous connaissez des méthodes qui offrent une latence très faible.
Depuis la sortie du premier modèle il y 3 ans (début 2012), la fondation Raspberry Pi n’a cessé d’améliorer le PCB de ce mini ordinateur. Toutes les versions actuelles sont basées sur la même puce Broadcom BCM2835 qui intègre un CPU (processeur), un GPU (processeur graphique), la mémoire SDRAM et un DSP. La différence entre les 4 modèles existants aujourd’hui (hormis la version compute module que je laisse de côté pour le moment), se joue essentiellement au niveau du format de la carte et des ports disponibles.
Aujourd’hui, je vais vous parler du dernier né, le modèle A+, dont j’ai fait l’acquisition récemment, et qui représente pour moi le meilleur Raspberry Pi conçu à ce jour.
Les 4 modèles de Raspberry Pi
Il existe 4 modèles bien différents actuellement : A, B, B+ et A+ (par ordre de sortie). Je mets volontairement de côté les variantes du modèle B (256Mo ou 512Mo de SDRAM, avec ou sans polyfuse, la version 256Mo n’étant plus distribuée), ainsi que le compute module (qui n’est pas une carte prête à l’emploi, et qui ne représente pour moi que peu d’intérêt).
La page Wikipédia sur le Raspberry Pi expose de manière très détaillée les caractéristiques techniques de ces différents modèles : http://fr.wikipedia.org/wiki/Raspberry_Pi
Si vous découvrez l’univers des Raspberry Pi, sans rentrer dans les détails vous pouvez retenir que les modèles B sont dotés de plus de SDRAM (512Mo contre 256Mo pour les modèles A), et qu’ils disposent d’un port Ethernet (et accessoirement de ports USB supplémentaires). Une différence notable concernant les modèles A+ et B+ par rapport à leur homologues A et B, est qu’ils disposent d’un port GPIO plus fournis.
Cela étant dit, le modèle A+ se distingue de la fratrie sur trois critères essentiels, qui en font pour ma part, le meilleur Raspberry Pi actuel.
Raspberry Pi A+ : un PCB mieux pensé et des choix techniques très pertinents
Un design plus compact et moins encombrant
La première chose que l’on observe c’est que le modèle A+ est beaucoup plus compacte que tous les autres. En effet, il mesure 2 cm de moins en longueur. 2 cm ce n’est pas grand chose dit comme ça, mais c’est tout de même 1/4 plus petit que les autres modèles. En passant de 8,5 cm à 6,5 cm, le modèle A+ tient réellement dans le creux de la main. La différence se fait également sentir sur la balance puisque le modèle A+ ne pèse que 23g, soit presque deux fois moins que le modèle A (45g).
Mais ce qui fait réellement la différence au niveau de l’encombrement, ce sont les trois points suivants :
Le remplacement de port SD par un port micro-SD fait que la carte mémoire ne dépasse quasiment pas du PCB (on gagne encore 1,5 cm sur la longueur totale).
La suppression du port composite réduit la largeur, la suppression du port Ethernet le rend beaucoup plus plat que les modèles B et B+, et le port USB ressort moins de la carte ce qui permet de gagner encore 0,5 cm sur la longueur totale.
Enfin, et c’est le point le plus important, tous les ports (jack, HDMI, alimentation) sont du même côté de la carte et orienté dans le même sens
A gauche, le modèle A (qui a les mêmes mensurations et le même agencement que le modèle B), à droite, le modèle A+. De l’extrémité du port USB à la carte SD, on note une différence de 4 cm au total.
Le fait d’avoir les ports du même côté réduit considérablement l’encombrement de l’ensemble.
A gauche, avec le modèle A, ça part dans tous les sens, c’est très pénible à organiser, il faut déblayer la moitié du bureau pour travailler correctement ! Avec le modèle A+ en revanche, à droite, c’est propre, compact, facile à organiser et on peut facilement loger l’ensemble dans un boitier Un immense merci à l’équipe de la Raspberry Pi Foundation
La consommation
Le deuxième gros point fort du modèle A+ par rapport aux autres modèles est sa consommation réduite.
Alors que le modèle B tirera près de 700mA de courant, le modèle A+ ne nécessitera qu’un courant de 200mA, soit plus de trois fois moins. Ce qui veut dire que pour un projet qui nécessite de faire fonctionner le Raspberry Pi sur batterie (voir Comment alimenter votre Raspberry Pi avec une batterie), on pourra tenir 3 fois plus longtemps.
Avec une consommation de 1W seulement, l’alimentation du Raspberry Pi avec un panneau solaire devient tout à fait envisageable Par exemple, ce chargeur de 6W Expower, dont on peut supposer un rendement effectif de 20%, pourrait faire tourner un Pi A+ 24h/24 (à tester).
Le GPIO 40 broches
Alors que les ports GPIO des modèles A et B ne disposaient que de 26 broches, celui du modèle A+ (et B+) en comporte 40.
A gauche, le GPIO à 26 broches des modèles A et B. A droite, le nouveau port GPIO à 40 broches.
On retrouve les mêmes types de bus, mais en plus grand nombre
Conclusion
Avec son format compact et son design mieux étudié, son poids plume, sa consommation très faible et son port GPIO aux possibilités démultipliées, le Raspberry Pi A+ est le modèle qui conviendra le mieux aux projets dits « embarqués » (robots, sondes, caméras, datalogger, ). Les modèles B et B+ seront, quant à eux, à privilégier pour créer de petits serveurs (web, NAS, domotique) ou pour des applications multimédia (XBMC, MPD), qui nécessitent plus de mémoire et un port Ethernet.
Un petit regret toutefois, le modèle A+ n’est doté que de 256Mo de RAM ce qui peut être limitant pour certains projets.
Aujourd’hui, j’élargis le sujet en introduisant le contrôleur RFXCOM RFXtrx433E et le logiciel Domoticz. L’ensemble piloté par un Raspberry Pi forme un contrôleur domotique ultime.
Le Raspberry Pi a réellement sa place dans une installation domotique car il offre, pour une bouchée de pain, de nombreuses possibilités grâce à son port GPIO et ses ports USB. De nombreux périphériques et capteurs peuvent ainsi être directement branchés sur une Raspberry Pi. Ajoutez à cela, un contrôleur Z-Wave et un transmetteur RFXCOM RFXtrx433E et vous voilà armé pour domotiser toute votre maison en utilisant de nombreux modules de constructeurs et de marque variés. L’ensemble étant disponible à un prix très abordable et offrant un niveau de personnalisation sans limite, il s’agit vraiment pour moi d’un combo ultime
ATTENTION : Pour que Z-Way et Domoticz puissent fonctionner ensemble sur le même Raspberry Pi, il est impératif d’utiliser une Raspbian vierge puis d’installer Z-Way et Domoticz. Il ne faut pas utiliser les images pré-paquagées de Z-Way ou de Domoticz.
Une fois Domoticz Installé, il suffit de configurer les contrôleurs que vous souhaitez gérer en allant dans l’onglet « Setup ». Dans cet exemple, nous nous limitons au module Razberry et au transmetteur RFXCOM :
A partir de là, vous êtes prêt à utiliser tous les modules domotique fonctionnant en Z-Wave ainsi que la plupart des modules fonctionnant en radio sur la banque de fréquence 433,92 Mhz. Autant dire que les possibilités sont grandes. Vous pouvez acheter n’importe quel module Z-Wave, mais vous pouvez également vous rendre dans n’importe quel magasin de bricolage et acheter de nombreux modules domotiques compatibles avec le transmetteur RFXCOM, dont vous pouvez consulter la liste ici : http://www.rfxcom.com/store/Transceivers/14103 (dans la section « Will Support »)
Quelques exemples avec mon installation actuelle
Outre les modules « prise de courant » pour piloter mes lumières comme expliqué dans l’article Contrôle de l’éclairage avec le module Z-Wave Razberry, je me suis équipé de capteurs de température et d’humidité, de modules pour piloter mes volets roulants, de détecteurs d’ouverture de porte, de capteurs de luminosité, de module intégrés pour mes plafonniers, etc…
Voici en vrac, la liste de quelques modules que j’utilise :
Domoticz offre de nombreuses fonctionnalités, comme la programmation de scénarios, la gestion de caméra de surveillance, etc… Je vous laisse découvrir tout cela par vous mêmes
Dans mon prochain article, suite à la demande de plusieurs lecteurs, j’expliquerai comment utiliser l’API de Domoticz pour afficher la température et d’autres données météo sur le Pi HomeDashScreen
Après quelque souci pour héberger l’article très complet qu’il à réalisé sur son projet, j’ai proposé à Tim d’héberger et de rellayer son travail Voici donc la retranscription complète de son article
RASPBERRY BATEAU
Sommaire
Le Raspberry Bateau
Inventaire des éléments utilisés
Connexion 3g / Hotspot Wifi
Commande des Servomoteurs
Commande photo par Webcam et serveur distant
Interface graphique Web sur mobile
Streaming du flux vidéo de la webcam
Commander un projecteur à LEDs
Mais alors ça donne quoi tout ça ??!
Introduction
En 1999, j’ai fabriqué une maquette de bateau en bois d’environ 1 mètre de long. Ce bateau embarque deux servomoteurs. L’un est rattaché à un variateur qui permet de faire tourner plus ou moins vite un moteur sur lequel est rattaché une hélice. L’autre permet de changer l’angle du gouvernail. Ces deux servomoteurs peuvent être contrôlés par onde radio à l’aide d’une télécommande que l’on trouve dans les magasins de modélisme ou d’électronique.
Le défi que je me suis donné était de remplacer la télécommande par un téléphone ou une tablette. Je voulais aussi ajouter une caméra pour voir ce que le bateau voit et pouvoir prendre des photos.
Je me suis dit que d’autres auraient des défis similaires donc j’ai décidé de partager tous les détails techniques sur mon expérience. Bien-sûr, ne soyez pas trop critiques, il existe probablement des choix bien meilleurs que les miens.
Je voudrais remercier tout particulièrement Olivier, l’auteur du blog MagdiBlog qui a été une véritable source d’inspiration pour moi. Son blog est exceptionnellement bien écrit et agréable à lire. Ces projets sont intéressants, détaillés et précis. Plusieurs parties de mon projet n’auraient pas pu être réalisées sans ses explications. J’ai réutilisé des codes appartenant à plusieurs de ses projets pour arriver à mes fins. Je recommande vivement son site à tous ceux qui s’intéressent au Raspberry Pi.
La cabine se retire pour accéder aux moteurs, servomoteurs, Raspberry Pi, batteries etc.
Sur le dessus de la cabine, on retrouve la webcam qui permet de filmer et prendre des photos. Le pont arrière laisse ressortir un adaptateur USB WIFI :
Inventaire des éléments utilisés
Voici le dongle WIFI D-Link DWA-131 Nano que j’ai utilisé :
Lorsque l’on ouvre les entrailles du bateau, voici les différents éléments que l’on retrouve :
1. Une batterie 6V 12A pour alimenter le moteur.
2. Un moteur auquel est rattaché un arbre moteur qui entraîne l’hélice du bateau.
3. Un servomoteur qui pilote par son angle de rotation et à l’aide de la tige métallique un variateur.
4. Le variateur qui va définir la vitesse et le sens de rotation du moteur.
5. Un Raspberry Pi modèle B 512MB protégé par une coque dont j’ai découpé une partie pour laisser l’accès aux broches GPIO. C’est lui le chef d’orchestre qui va :
recevoir les commandes de mon téléphone
piloter le servomoteur qui contrôle le moteur
piloter le servomoteur qui contrôle l’angle du gouvernail
prendre des photos à l’aide la webcam, les stocker en local sur sa carte SD et envoyer une miniature à mon téléphone par mail.
filmer à l’aide de la webcam et « streamer » le flux vidéo à mon téléphone :
On ne la voit pas très bien mais il s’agit d’une batterie externe portable qui sert de chargeur de secours pour des téléphones ou tablettes Apple. Celle-ci convient parfaitement comme source d’alimentation du Raspberry Pi. Elle tient d’ailleurs pas mal de temps j’étais agréablement surpris : http://www.amazon.fr/gp/product/B0089MLH7Q/ref=oh_details_o02_s00_i00?ie=UTF8&psc=1
8. Une pile 4.5 V qui me permet d’alimenter un petit projecteur à LED contrôlé par une broche du port GPIO.
Pour plus de simplicité et afin faire une livraison groupée, j’ai essayé de trouver tous les éléments électroniques sur Amazon. En ce qui concerne les éléments batteries, coupleurs de piles, moteur et servomoteurs, je les ai obtenus dans un magasin d’électronique et de modélisme ici : http://www.electronique-diffusion.fr/
Une fois les courses faites et tous les éléments assemblés, il est temps de mettre un peu les mains dans le code !
Je ne m’étendrai pas sur tout ce qui concerne l’installation du système du Raspberry Pi car tout est très bien expliqué sur leur site ou sur de nombreux blogs. Pour ce projet, j’ai installé le système Raspbian : http://www.raspberrypi.org/downloads/
Connexion 3g / Hotspot Wifi
Commençons par la connexion entre le téléphone et le bateau.
Il existe plusieurs possibilités mais le principe est bien de créer un réseau sans fils entre le téléphone (ou la tablette) et le Raspberry Pi. Ce réseau doit être fiable car ce serait bête de perdre la connexion alors que le bateau se trouve au milieu du lac !
J’ai tout d’abord essayé de configurer (connecté au Raspberry Pi) un modem usb 3g dans lequel j’ai mis une carte SIM de l’opérateur Free. En suivant les instructions du site d’Olivier ici j’ai pu configurer le modem et obtenir du réseau internet sur le Raspberry. Ce système est très dépendant de la qualité du réseau 3g de Free et malheureusement les performances n’étaient pas au rendez-vous… J’ai eu plusieurs déconnexions. Cependant, sachez que ce système fonctionne avec le Raspberry Pi si vous cherchez à avoir de l’internet n’importe où. Si vous voulez plus d’infos sur cette partie, j’ai pris des notes que je peux partager mais je ne les ai pas mises sur ce blog car j’ai opté pour la solution du hotspot Wifi.
J’ai donc opté pour la création d’un réseau privé WIFI. Mon téléphone Android et mon opérateur me permettent de transformer mon téléphone en modem WIFI. Vous trouverez sur internet plein de tutoriels pour réaliser cette opération. Votre téléphone créé alors un point d’accès WIFI auquel il est possible de se connecter comme le fait votre box. L’idée est de créer se réseau et de configurer le Raspberry Pi pour qu’il s’y connecte automatiquement au démarrage.
Une fois le téléphone configuré, vous devez trouver sur quelle plage ip il se connecte.
Tout d’abord, il faut connecter le dongle WIFI usb au Raspberry Pi :
NOTE : J’ai choisi d’utiliser un câble USB d’extension pour faire sortir le dongle du bateau.
Connectez aussi votre Raspberry à votre réseau ethernet et connectez vous en SSH au Raspberry. Je ne m’étendrai pas sur comment réaliser cela car tout est expliqué en détail sur internet.
NOTE : Je passe toutes mes commandes en root comme ça je ne suis pas embêté à entrer sudo, le mot de passe etc… Je sais c’est pas bien mais… on s’en fiche !
Modifiez le fichier « /etc/network/interfaces » comme suivant à l’aide de la commande vi :
auto lo
iface lo inet loopback
iface eth0 inet dhcp
allow-hotplug wlan0
auto wlan0
iface wlan0 inet dhcp
wpa-ssid NOM_DE_VOTRE_WIFI
wpa-psk MOT_DE_PASSE_DU_WIFI
Relancez le réseau wifi à l'aide des commandes suivantes :
sudo ifdown wlan0
sudo ifup wlan0
Pour connaître l’ip que votre téléphone vous a attribué, entrez la commande « ifconfig » et notez l’adresse ip de la carte wlan0. Voici ce que me donne ma configuration :
Le téléphone peut aussi vous indiquer qu’un nouveau périphérique s’est connecté au réseau.
Quand le bateau n’est pas connecté :
Quand le dongle Wifi obtient une adresse ip :
L’adresse ip du bateau sera donc 192.168.43.115. Comme c’est une configuration DHCP, l’adresse pourrait changer au reboot mais le téléphone enregistre la MAC adresse de la carte et pour ma part l’ip attribuée a toujours été la même. Si on souhaite vraiment qu’elle ne change pas, il suffit de modifier le fichier précédent et d’enregistrer l’ip comme static.
Note importante : Activez toujours le point d’accès wifi depuis votre téléphone avant de démarrer le Raspberry. Ainsi, il prendra tout de suite l’ip. Dans le cas contraire, si vous n’avez pas la possibilité de vous connecter en ethernet (par exemple vous êtes déjà au bord du lac), il vous faudra éteindre votre Raspberry « non-proprement » en lui retirant l’alimentation ce qui risque de corrompre le système de fichier et bloquer le système au prochain démarrage.
Bien ! Nous savons maintenant faire en sorte que le Raspberry Pi et le téléphone se retrouve dans le même réseau WIFI privé au démarrage. Après plusieurs tests je n’ai vraiment pas été déçu par la portée de ce petit réseau. J’arrive à piloter le bateau jusqu’à une bonne dizaine de mètres.
Commande des Servomoteurs
Pour piloter les servomoteurs, j’ai utilisé le logiciel pour Raspberry ServoBlaster. Celui-ci créé une interface pour piloter plusieurs servomoteurs depuis les broches du port GPIO. Voici les commandes pour l’installer et le configurer :
Positionnez-vous dans le dossier « /PiBits/ServoBlaster/user« . Vous devriez y trouver les fichiers suivants :
root@raspberrypi:~/PiBits/ServoBlaster/user# ls
init-script Makefile servod.c
Ensuite :
root@raspberrypi:~/PiBits/ServoBlaster/user# make servod
gcc -Wall -g -O2 -o servod servod.c -lm
root@raspberrypi:~/PiBits/ServoBlaster/user# ./servod
Board revision: 2
Using hardware: PWM
Using DMA channel: 14
Idle timeout: Disabled
Number of servos: 8
Servo cycle time: 20000us
Pulse increment step size: 10us
Minimum width value: 50 (500us)
Maximum width value: 250 (2500us)
Output levels: Normal
Using P1 pins: 7,11,12,13,15,16,18,22
Using P5 pins:
Servo mapping:
0 on P1-7 GPIO-4
1 on P1-11 GPIO-17
2 on P1-12 GPIO-18
3 on P1-13 GPIO-27
4 on P1-15 GPIO-22
5 on P1-16 GPIO-23
6 on P1-18 GPIO-24
7 on P1-22 GPIO-25
Après installation, ci-dessus, la configuration par défaut est affichée. Pour en savoir plus sur le fonctionnement de ServoBlaster, vous pouvez aussi entrer la commande help :
C’est à vous ensuite d’en apprendre plus sur le modèle de votre servomoteur pour savoir quelles valeurs configurer. Par exemple pour les miens en faisant une petite recherche Google :
Je me sers ensuite de ces informations pour configurer au mieux ServoBlaster. J’ai trouvé que le plus simple était de faire des tests en envoyant des commandes de pourcentage courtes pour voir comment le servo réagi et où se trouvent les extrémités. Au final, j’ai utilisé les broches 7 et 11 pour piloter mes deux servomoteurs (c’est à dire les GPIO 4 et 17 d’après le tableau de mapping plus haut). Voici un exemple de fichier de test pour mes deux servomoteurs :
En regardant de plus prés les explications sur ServoBlaster et les exemples, vous n’aurez aucun mal à comprendre mon fichier de test. Attention à bien donner les droits d’exécution au fichier.
Voici le résultat à l’exécution du fichier :
Un petit schéma de connexion des servomoteurs s’impose :
L’alimentation est constituée d’un coupleur de 4 piles AAA de 1,5V bloquées derrière le gouvernail :
Conclusion, à travers une commande SSH je peux piloter au degré près l’angle de rotation du moteur et ainsi l’angle du gouvernail et l’angle sur le variateur de vitesse du moteur.
Commande photo par Webcam et serveur distant
Ok ok ma webcam a une sale tête… En fait, mon premier projet était de la mettre sous le bateau dans un boitier transparent pour pouvoir filmer sous l’eau. J’ai voulu rendre étanche tout ça avec de la mousse isolante mais j’ai eu quelques petits soucis (imaginez l’état de mes doigts…). J’ai donc opté pour la simplicité en la mettant sur la cabine :
De cette façon je pourrai voir en direct ce que voit le bateau et prendre des photos sympas.
En ce qui concerne la partie « prendre des photos », ce que je souhaite est que la webcam prenne une photo quand je le commande à l’aide mon téléphone, qu’il stocke la photo sur la carte SD (d’où la carte de 32 GB), que le Raspberry compresse et miniaturise cette photo et qu’il me l’envoie par mail avec la date et l’heure.
Voici le résultat. On peut voir mon frère en face qui pilote son bateau avec une télécommande radio :
Alors ! Comment ça marche !?
Tout d’abord, comme c’est très bien expliqué sur le site d’Olivier, il me faut un serveur qui recevra les miniatures du Raspberry et me les transférera par mail sur mon téléphone. Comme le bateau est piloté en Wifi, ma 3g est toujours activée et connectée au net donc je peux recevoir les photos sans problèmes.
J’ai loué un petit serveur dédié chez OVH pour cette tâche. J’ai créé un domaine et une base de donnée dans laquelle on stockera les dates et les chemins vers les images. Cette partie là est propre à l’administration de votre serveur donc je ne m’étendrai pas sur le sujet.
Je créé une table dans ma base à l’aide de mon compte phpmyadmin comme ceci :
Pour le reste, j’ai suivi les instructions et codes qu’Olivier fourni sur son site donc je ne vais pas tout ré-expliquer. Vous trouverez tout sur le script pour la prise de photo ICI et sur le code côté serveur et la base de donnée ICI. Olivier l’explique beaucoup mieux que moi. Attention, il y a quand même des petites choses à connaitre (et des choses à modifier dans les scripts, votre nom de domaine, les identifiants de connexion à la base de donnée etc.) en php et mysql donc si vous n’y connaissez rien, ne vous attendez pas à ce que ce soit du copier-coller des scripts.
En tout cas, après avoir pris quelques photos, voici le résultat dans la base de donnée sur le serveur OVH :
A la différence du projet d’Olivier, la photo est prise quand le Raspberry Pi reçoit la commande SSH qui lui dit d’exécuter le script timelapse.sh. Si vous n’avez pas bien tout lu, sachez que c’est le logiciel streamer qui permet de prendre ces photos depuis le Raspberry et la commande convert compresse et redimensionne la photo et la commande curl pour l’envoyer au serveur OVH. Tout ça se trouve dans le script php.
Interface graphique Web sur mobile
Au début, je voulais commander le bateau à l’aide de mon téléphone en développant une application Android native. J’ai donc développé une application qui permet d’envoyer des commandes SSH. Vous me direz « Olalala, faut utiliser les sockets c’est plus rapide et plus efficace ! » sauf que je ne suis pas un bon développeur Android et que je n’ai pas eu le temps de fouiller le code pour savoir comment le faire. Comme je savais par contre comment envoyer des commandes SSH je me suis dit parfait. Sauf que le résultat n’était vraiment pas terrible et lent même si ça marchait. Et puis je me suis dit que ce serait sympa de faire une interface web plutôt qu’une application native. Comme ça je pourrai d’une part me perfectionner sur PHP et d’une autre part piloter mon bateau depuis n’importe quel mobile que ce soit de l’Android ou du Mac. L’idée me plaisait donc c’est parti.
Voilà d’abord le résultat :
L’image que l’on voit en bas c’est ce que film la caméra. J’en parlerai plus loin.
Je ne me suis pas cassé la tête et il y a sûrement des codes beaucoup plus propres que le mien mais au moins ça a le mérite de fonctionner. Le principe est simple, chaque bouton envoie une commande SSH en passant par php à un serveur web installé sur le Raspberry. Ensuite, le Raspberry traite la commande comme si je venais de la taper en direct dans une console. J’étais agréablement surpris car même en Wifi ça réagit très vite.
Quelques explications sur les boutons :
Envoie la commande au Raspberry Pi de s’éteindre proprement. Comme ça une fois qu’on a fini de faire « mumuse » avec son bateau on est pas obligé d’éteindre brutalement le Raspberry en lui retirant l’alimentation. ça évite la corruption du système de fichier linux.
Prend une photo, en fait une miniature et l’envoie au serveur OVH.
Petite remarque ! Pour le moment, je ne peux pas prendre des photos et en même temps que je retransmet le flux vidéo (j’en parle plus bas). Pour prendre une photo, il faut d’abord appuyer sur l’arrêt de la Webcam et ensuite sur le bouton l’appareil photo.
Éteint ou allume la webcam.
Met le servomoteur qui contrôle la vitesse en position ou le variateur arrête le moteur.
Les flèches indiquent la direction où je souhaite que le bateau aille. A l’appui sur un bouton de direction, si la flèche va vers l’avant, le gouvernail change d’angle suivant la direction et le moteur tourne dans le sens qui fait avancer le bateau. Donc à chaque appui sur une flèche, une commande php exécute une commande de ServoBlaster ce qui modifie l’angle des servomoteurs.
Ce bouton commande tout simplement l’exécution du script qui fait bouger les servomoteurs un peu dans tous les sens (comme la vidéo plus haut) ce qui permet de tester que tout fonctionne avant de le mettre à l’eau. On pourrait imaginer aussi un script qui fait tourner le bateau en huit comme une sorte de pilotage automatique.
L’appui sur l’un de ces boutons change l’angle du servomoteur qui contrôle la vitesse. On peut imaginer ce que l’on veut mais dans mon cas j’ai choisi le faire ralentir le bateau.
Alors c’est parti pour l’installation du serveur web sur le Raspberry Pi !
Entrez la commande pour installer les librairies qui vont bien (php, apache etc.) :
apt-get install apache2 php5 libapache2-mod-php5
Pour voir si ça fonctionne il suffit de se connecter à l’adresse de votre raspberry dans un navigateur qui se trouve sur le même réseau :
Sinon par exemple pour montrer l’état d’une broche de votre port GPIO dans la page web, vous pouvez créer le fichier suivant dans /var/www :
On raffraichi la page web et on obtient l’état de la broche 0 :
Attention, le service Apache a un utilisateur www-data qui n’a pas les droits d’exécuter des scripts qui se trouvent dans /root avec la commande php exec. Pour régler ce problème il faut éditer le fichier des sudoers comme ceci :
# visudo
Ajouter cette ligne :
# User privilege specification
root ALL=(ALL:ALL) ALL
www-data ALL=(ALL:ALL) NOPASSWD:ALL
Ok ok encore une fois c’est pas le top de la sécurité mais on s’en fiche c’est un réseau privé.
Sinon pour un peu plus de sécurité vous pouvez préciser les commandes que vous souhaitez passer en sudo :
www-data ALL = (root) NOPASSWD: /bin/cp /root/test1 /root/test2
Bon une fois que tout ça est fait il ne nous reste plus qu’à coder les actions de l’appui sur les boutons de la page html.
Voici le fichier index.php qui se trouve dans /var/www/Web. Dans mon cas je l’ai mis dans un répertoire Web mais vous le mettez où vous voulez du moment que c’est dans /var/www :
Bon c’est plutôt basique est il y a sûrement encore plus simple mais je le rappelle je ne suis pas développeur php ! Après comme je le dis souvent, ça a le mérite de marcher et de satisfaire mes besoins !
Chaque bouton a une méthode post qui appelle un autre script php qui demande l’exécution d’un script stocké sous root. Woooooo ! Dans ce script il y a la commande qui déclenche l’action.
Exemple !
Je veux aller tout droit. J’appuie sur le bouton flèche « tout droit ».
Lors de son exécution, grâce aux commandes exec et sudo il execute en bash le script stocké dans /root.
Le header permet de faire comme si on avait rafraîchi la page web.
Le script /root/avance_tout_droit.sh est alors exécuté :
/root/PiBits/ServoBlaster/user/servod --cycle-time 30000 --max=300 --p1pins=7,11
#gouvernail tout droit
echo 0=38% > /dev/servoblaster
#avancer vite
echo 1=29% > /dev/servoblaster
sleep 0.2
et là on retrouve les commandes qui permettent le contrôle des servomoteurs.
NOTE : N’oubliez pas de rendre vos scripts exécutables ! (chmod …..)
Pour le fichier css c’est tout simple ! Je dirai même il n’y a pas plus simple ! J’ai découpé mon interface en 3 colonnes pour que les icônes des boutons soient bien alignés :
Une fois que vous avez compris le principe des fichier php qui appellent des script dans /root et bien il suffit de créer un fichier par action que vous souhaitez réaliser.
Encore une fois je sais qu’il est possible de ne pas créer autant de fichier et de faire quelque chose de plus propre mais je n’avais pas le temps de m’y plonger.
Streaming du flux vidéo de la webcam
Comme promis plus haut voici quelques explications sur la vidéo :
Note : Bon j’aurais pu en parler plus haut mais pour vérifier que votre webcam est reconnue par le Raspberry Pi, vérifiez que l’entrée video0 existe dans /dev.
Le logiciel que j’utilise pour transmettre le flux vidéo est MJPG-streamer. C’est comme un petit server HTTP installé sur le Raspberry Pi qui transmet le flux vidéo capturé par la webcam en utilisant le protocol http dans le format motion jpeg. Pour voir le flux une fois que le serveur est actif, il suffit d’ouvrir un navigateur compatible et d’entrer l’ip du Raspberry avec le port associé à MJPG-streamer.
Il faut installer certains package (n’oubliez pas d’abord de mettre à jour votre système avec update et upgrade d’apt-get) :
apt-get install libv41-0
Récupérez le package mjpg-streamer (créé par Tom Stoeveken) ou alors il existe aussi un package un peu customisé pour le Raspberry que l’on peut récupérer :
wget http://iqjar.com/download/jar/soft/mjpg-streamer.tar.gz
tar -zxvf mjpg-streamer-rpi.tar.gz
cd mjpg-streamer
./mjpg-streamer.sh start
Pour tester si tout fonctionne et que l’on voit le flux vidéo dans une page web, ouvrez un navigateur :
http://example.com:8083/?action=stream
Le port par défaut est 8083.
Si on veut l’intégrer dans une page web comme je l’ai fait, il faut utiliser une balise image :
Pour moi ça n’a pas marché donc j’ai retiré les paramètres de taille et là miracle ! J’ai testé avec Chrome, Firefox, le navigateur natif d’android et celui d’apple, ça fonctionne très bien !
Comme je voulais filmer sous l’eau, je souhaitais aussi pouvoir allumer un projecteur à leds pour donner un peu de lumière à la camera dans les eaux un peu troubles. ça fonctionne très bien aussi.
J’ai récupéré une petite lampe à leds qui sert à éclairer en se branchant sur le port usb d’un ordinateur.
J’ai découpé le pied et retiré le tuyau flexible et ça m’a donné un excellent projecteur à leds alimenté en 5V.
C’est un broche du port GPIO qui va contrôler l’allumage et l’extinction des LEDs. Encore un petit schéma rapide :
Pour contrôler l’état des broches du GPIO, le plus simple est d’utiliser WiringPi :
git clone git://git.drogon.net/wiringPi
cd ./wiringPi
./build
On voit bien que la broche 7 est en sortie mais sa valeur est LOW donc le transistor ne laissera pas passer le courant qui allumera les LEDs. Il faut donc passer la sortie de cette broche au niveau haut (High) :
Pour allumer la led depuis une page web et faire en sorte que l’affichage soit dynamique (c’est à dire que lorsque j’appuie sur le bouton allumer les LEDs l’image du bouton change pour montrer que c’est allumé) il faut utiliser du php mais aussi du javascript.
Voici le code à mettre dans /var/www/Web. Il y a 3 fichiers et un répertoire contenant les images. Je me suis inspiré d’un tutoriel sur un site mais je n’arrive pas à le retrouver pour le citer…
INDEX.PHP
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Raspberry Pi Gpio</title>
</head>
<body style="background-color: black;">
<!-- On/Off button's picture -->
<?php
//this php script generate the first page in function of the gpio's status
$status = array (0);
$i = 3; // Numéro de la PIN utilisée
//set the pin's mode to output and read them
system("gpio mode ".$pin." out");
exec ("gpio read ".$i, $status[$i], $return );
//if off
if ($status[$i][0] == 0 )
{
echo ("<img id='button_".$i."' src='data/img/red/red_".$i.".jpg' alt='off'/>");
}
//if on
if ($status[$i][0] == 1 )
{
echo ("<img id='button_".$i."' src='data/img/green/green_".$i.".jpg' alt='on'/>");
}
?>
<!-- javascript script.js est inclu dans le fichier -->
<script src="script.js"></script>
</body>
</html>
GPIO.PHP
<!-- This page is requested by the JavaScript, it updates the pin's status and then print it -->
<?php
//Getting and using values
if (isset ($_GET["pin"]) && isset($_GET["status"]) )
{
$pin = strip_tags($_GET["pin"]);
$status = strip_tags($_GET["status"]);
//set the gpio's mode to output
system("gpio mode ".$pin." out");
//set the gpio to high/low
if ($status == "0" ) { $status = "1"; }
else if ($status == "1" ) { $status = "0"; }
system("gpio write ".$pin." ".$status );
//reading pin's status
exec ("gpio read ".$pin, $status, $return );
//printing it
echo ( $status[0]);
} //print fail if cannot use values
else { echo ("Erreur dans l'URL"); }
?>
SCRIPT.JS
//JavaScript, use pictures as buttons, sends and receives values to/from the Rpi
var button_3 = document.getElementById("button_3");
//this function sends and receives the pin's status
function change_pin (pin, status) {
//this is the http request
var request = new XMLHttpRequest();
request.open( "GET" , "gpio.php?pin=" + pin + "&status=" + status );
request.send(null);
//receiving information
request.onreadystatechange = function () {
if (request.readyState == 4 && request.status == 200) {
return (parseInt(request.responseText));
}
//test if fail
else if (request.readyState == 4 && request.status == 500) {
alert ("server error");
return ("fail");
}
//else
else { return ("fail"); }
}
}
//these are all the button's events, it just calls the change_pin function and updates the page in function of the return of it.
button_3.addEventListener("click", function () {
//if red
if ( button_3.alt === "off" ) {
//use the function
var new_status = change_pin ( 3, 0);
if (new_status !== "fail") {
button_3.alt = "on"
button_3.src = "data/img/green/green_3.jpg";
return 0;
}
}
//if green
if ( button_3.alt === "on" ) {
//use the function
var new_status = change_pin ( 3, 1);
if (new_status !== "fail") {
button_3.alt = "off"
button_3.src = "data/img/red/red_3.jpg";
return 0;
}
}
} );
Mais alors ça donne quoi tout ça ??!
Rien ne vaut une petite vidéo !
Désolé pour la qualité de la vidéo c’est pas terrible mais j’ai pas pu faire mieux… En tout cas j’espère que ce tutoriel vous a plu. N’hésitez pas à laisser un petit commentaire ICI. Vous pouvez aussi poser vos questions ou demander des précisions. Je m’efforcerai d’y répondre au mieux.
D’une excellente qualité de fabrication et capable de supporter jusqu’à 3500W sur 16A, vous pourrez utiliser ce module pour piloter tous les appareils (ou presque) de votre maison (lampe, petit électroménager, appareil multimédia,…). Sur la face avant, il y a un bouton qui sert d’interrupteur manuel doté d’un témoin lumineux rouge qui s’allume lorsque la prise est en position « On« .
Bien que le boitier semble volumineux, il reste relativement discret comme vous pouvez le constater sur les photos ci-contre et ci-dessous.
A l’heure où j’écris cet article, je dispose de cinq de ces modules : lampe de la cuisine, lampe du bureau, lampe du séjour, lampes autour de la télé, et un pour le sapin de Noël
Razberry et Z-Way
Revenons en au module Razberry. Une fois enfiché sur le port GPIO du Pi, il ne vous reste plus qu’à booter et installer Z-Way, le soft proposé par Z-Wave.me.
Note : Z-Way est encore en béta, son aspect n’est donc pas aussi travaillé que ce dont on a l’habitude de nos jours, et les fonctionnalités restent limitées. Toujours est-il que les manques fonctionnels actuels peuvent être contournés facilement grâce à une API JSON
Vous pouvez acheter le module Razberry directement sur Amazon :
L’installation de Z-Way sur Raspbian se fait très simplement grâce au script mis à disposition sur le site du fabricant :
A la fin de l’installation, il suffit de rebooter le Pi. L’interface web de Z-Way est alors disponible directement sur le port TCP/8083 En vous connectant avec votre navigateur web, vous aurez le choix entre quatre interfaces.
Pour continuer, nous choisirons l’interface « Expert » qui est la plus complète (les autres interfaces étant plus des démonstrations, pour montrer le potentiel de Z-Way).
Association des modules
La première chose à faire, est d’associer (ou d’inclure pour coller ay langage Z-Wave ) nos modules « prise de courant » à notre contrôleur Z-Wave Razberry afin de créer un réseau Z-Wave. Pour cela, il suffit de se rendre dans le menu « Network->Network management » et de cliquer sur le bouton « include device« .
A ce moment là, Z-Way est à l’écoute d’un module désirant entrer dans le réseau. Sur les modules Everspring AN157-6, rien de bien compliqué, il suffit de maintenir le bouton appuyé quelques secondes jusqu’à ce que le témoin lumineux clignote (ce qui indique que le module est en mode « inclusion« ). Au besoin, voici le mode d’emploi du module : everspring_an157_doc.pdf
Une fois les modules correctement ajoutés dans le réseau Z-Wave, on peut voir l’état de chacun d’eux, et les tester grâce aux boutons « On/Off » (notez bien les numéros ID des modules, nous en aurons besoin un peu plus tard)Jour ! Nuit ! Jour ! Nuit ! Jour ! Nuit ! Je vous vois rigoler, mais je vous garantis que vous ferez la même chose
Vous en conviendrez, cette interface web, bien que tout à fait fonctionnelle, n’est pas très sexy…
Nous allons maintenant créer notre propre interface web adaptée à un affichage sur smartphone
Maintenant que vous savez tout à propos de cette fameuse API, nous allons créer une petite application web en HTML/PHP5/JavaScript.
Et voilà le résultat final sur mon smartphone
Note : Vous pouvez construire cette l’application web, soit directement sur le Pi qui détient le module Razberry, soit sur n’importe quelle autre machine Pour ma part, l’application web est exécutée sur un serveur tier
La première étape consiste à installer et configurer un serveur web Apache et PHP5. Je vous propose de suivre la procédure décrite dans cette article : PiHomeDashScreen – Installation et configuration
Une fois votre serveur web opérationnel, vous pouvez créer un répertoire « z-way » dans le répertoire par défaut d’Apache « /var/www », et y placer les fichiers décrits ci-après. L’idée est simple, il s’agit d’une simple page web qui représente chaque module par une image en forme d’ampoule (allumée ou éteinte). Lorsqu’on clique sur une ampoule, on envoie une requête AJAX qui enverra à son tour la requête HTTP GET à l’API Z-Way pour répercuter l’ordre donné
<?php
// nom des modules ainsi que leur ID que vous trouverez dans l'interface web z-way
$devices = array(
'Cuisine' => 3,
'Salon' => 6,
'Télé' => 5,
'Bureau' => 2,
'Sapin' => 4
);
// adresse IP du Pi sur lequel Z-Way est installé
$pi_zway = "1.2.3.4";
?>
ajax.php
<?php
header('Content-type: text/html; charset=utf-8');
require_once('conf.php');
function httpGet ($url) {
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$return = curl_exec($curl);
curl_close($curl);
return $return;
}
$cmd = $_REQUEST['cmd'];
$val = $_REQUEST['val'];
$device_id = $_REQUEST['device_id'];
if($val == 'on'){$val = 255;}else {$val = 0;}
// permet de changer l'état d'un module
if($cmd == 'set'){
$url = "http://".$pi_zway.":8083/ZWaveAPI/Run/devices[".$device_id."].instances[0].commandClasses[0x25].Set(".$val.")";
echo httpGet ($url);
}
// permet de récupérer l'état d'un module
else if($cmd == 'get'){
$url = "http://".$pi_zway.":8083/ZWaveAPI/Run/devices[".$device_id."].instances[0].commandClasses[37].Get()";
echo httpGet ($url);
}
// permet de modifier l'état de tous les modules
else if($cmd == 'set_all'){
foreach($devices as $device_name => $device_id) {
$url = "http://".$pi_zway.":8083/ZWaveAPI/Run/devices[".$device_id."].instances[0].commandClasses[0x25].Set(".$val.")";
echo httpGet ($url);
}
}
// recupère le dernier statut
else if($cmd == 'status'){
$url = "http://".$pi_zway.":8083/ZWaveAPI/Data/".time();
echo httpGet ($url);
}
// default
else{
return "";
}
?>
main.js
Note : N’oubliez pas de télécharger la dernière version de jQuery
var status_timeout;
/* Z-Way */
function zWave_AN157_set_all (val) {
$.ajax({
async : false,
type: "POST",
url: "ajax.php",
data: "cmd=set_all&val="+val,
success: function(html){
zWay_status_all ();
}
});
}
function zWave_AN157_set (device_id) {
var status = $("#status_"+device_id).val();
if(status == '255'){
var val = 'off';
}
else{
var val = 'on';
}
$.ajax({
async : false,
type: "POST",
url: "ajax.php",
data: "cmd=set&device_id="+device_id+"&val="+val,
success: function(html){
zWave_AN157_get (device_id);
}
});
}
function zWave_AN157_get (device_id) {
$.ajax({
async : false,
type: "POST",
url: "ajax.php",
data: "cmd=get&device_id="+device_id,
success: function(html){
zWay_status (device_id);
}
});
}
function zWay_status (device_id) {
$.ajax({
async : false,
dataType: "json",
type: "POST",
url: "ajax.php",
data: "cmd=status",
success: function(html){
var updatetime = html['updateTime'];
if(typeof html['devices.'+device_id+'.instances.0.commandClasses.37.data.level'] != 'undefined'){
var level = html['devices.'+device_id+'.instances.0.commandClasses.37.data.level']['value'];
if(level == '255'){
$("#light_"+device_id).attr('src', 'light_on.png');
}
else{
$("#light_"+device_id).attr('src', 'light_off.png');
}
$("#status_"+device_id).val(level);
}
$("#status").html(updatetime);
}
});
}
function zWay_status_all () {
$(".device_status").each(function (index) {
var ds_id = $(this).attr('id').split("_");
var d_id = ds_id[1];
zWave_AN157_get (d_id);
});
}
function updateStatus () {
zWay_status_all ();
status_timeout = setTimeout("updateStatus()", 10000);
}
Enfin, voici les deux images d’ampoules utilisées :
Avertissement
Le code source ci-dessus est créer dans le cadre d’un exemple simple, il peut et doit être optimisé et sécurisé
Si vous souhaitez avoir accès à cette application web depuis l’extérieur de votre réseau local, je vous conseille fortement de mettre en place un contrôle d’accès afin d’éviter que n’importe qui ne prenne le contrôle de votre maison
Dans un prochain article, je décortiquerai une installation complète et sécurisé à double authentification : certificat client et mot de passe.
Programmer l’allumage et l’extinction des lumières à heure fixe
Il peut être intéressant de programmer l’allumage et l’extinction des lumières (ou tout autre appareil) à heure fixe. Pour cela, rien de plus simple, il suffit de lancer les requêtes HTTP GET à Z-Way en utilisant CRON
Voici ma crontab qui allume les lumières de mon séjour du lundi au vendredi de 7h à 8h, puis de 19h à 1h tous les jours de la semaine
# m h dom mon dow command
#########################
# LIGHTS
#########################
0 7 * * 1-5 /root/z-way_lights.sh on
0 0 * * 1-5 /root/z-way_lights.sh off
0 19 * * * /root/z-way_lights.sh on
0 1 * * * /root/z-way_lights.sh off
Et voici le contenu du script /root/z-way_lights.sh :
#!/bin/bash
devices="2 3 5 6"
if [[ $# -eq 0 ]] ; then
exit 1;
fi
if [ $1 == "off" ] ; then
val=0
elif [ $1 == "on" ] ; then
val=255
else
exit 1;
fi
for n in $devices ; do
wget -o ./z-way.api -O ./z-way.api http://127.0.0.1:8083/ZWaveAPI/Run/devices%5B$n%5D.instances%5B0%5D.commandClasses%5B0x25%5D.Set%28$val%29
done
exit 0;
Tout cela fonctionne très bien depuis maintenant quelques semaines Il me tarde de faire l’acquisition d’autres modules Z-Wave Je pense notamment à des prises avec variateur telles que les Everspring AD142-6, pour allumer la lumière progressivement le matin dans la chambre lorsque le réveil sonne
Dans mon prochain article, je parlerai de vidéo surveillance A suivre…
Il n’y a plus aucun doute, avec 2014 nous entrons dans l’ère de la domotique et des technologies du « tout connecté » ! Je m’en réjouis car j’attendais cela avec impatience
Dans cet article, nous allons voir comment le Raspberry Pi peut vous permettre de domotiser votre maison à moindre frais en s’appuyant sur le protocole z-wave
Domotique
Derrière le mot « domotique » se cache de nombreuses technologies et des usages très variés. Il est question par exemple de commander l’allumage de ses lumières, contrôler son chauffage, programmer l’ouverture de ses volets,… On parle également de la mesure de la consommation des équipements électriques, de la température des pièces, de détecter les incendies, de collecter toutes les données qui permettent à une maison ou un bâtiment de fonctionner… Mais la domotique c’est également la sécurité des personnes, la télésurveillance, les caméras connectées, les alarmes, les capteurs de présence, la détection d’intrusion, etc…
Bref, la domotique c’est tout ce qui touche de près ou de loin à l’informatique, aux automatismes, aux télécommunications, à l’électronique et qui s’applique à l’habitat
Toutes ces technologies existent déjà depuis longtemps, mais à mon sens, la notion de domotique prend son sens quand toutes ces choses peuvent être pilotées de manière centralisée, et surtout, à distance à travers Internet En effet, je dispose déjà depuis quelques années de prises murales télécommandées, achetées dans une grande surface de bricolage, pour allumer et éteindre les lumières dans mon séjour ; c’est très pratique. En revanche, connecter ce système à un réseau informatique, et donc pouvoir le contrôler à distance et réaliser une infinité de programmes et de scénarios, augmente considérablement le potentiel de la chose
C’est pourquoi, à mon avis, en se rapprochant de nos ordinateurs, tablettes et autres périphériques mobiles, la domotique devient réellement pertinente
Z-Wave
Parmi les nombreux systèmes, marques et protocoles domotique existants, il y en a un qui se démarque et gagne en popularité. Il s’agit du protocole Z-Wave.
Ce protocole ouvert, communiquant par onde radio, fonctionne sur le principe du « maillage » (topologie mesh), c’est à dire que chaque « module » (prise de courant, capteur de température, détecteur de présence,…) retransmet les signaux afin de garantir une grande couverture. Le gros avantage de ce protocle est qu’il est « ouvert ». Par conséquent, il existe de nombreuses entreprises et marques qui proposent des produits compatibles entre eux
Le site de la Z-Wave Alliance rassemble tous les constructeurs et acteurs (plus de 250 à l’heure actuelle) qui travaillent autour du Z-Wave et référence aujourd’hui plus de 1000 produits Z-Wave Il y a de quoi faire !
Je préfère de loin ce type de protocole ouvert par rapport aux systèmes de grandes marques qui proposent leur écosystème chèr et fermé ! Surtout lorsqu’il s’agit de ma maison ! Selon, moi, un système domotique complet doit être ouvert et permettre à l’utilisateur de le maitriser comme il l’entend.
Razberry
Depuis quelques mois la société Z-Wave.me propose une carte d’extension pour nos chers petits Raspberry Pi : Razberry
Il s’agit d’un petit circuit qui se branche directement sur le port GPIO permettant ainsi au Pi de parler le Z-Wave
Ce module est livré avec le logiciel Z-Way (encore en développement) facilement installable sur Raspbian en suivant la procédure décrite sur le site z-wave.me – Documentation. Plusieurs interfaces web sont disponibles (desktop, mobile,…) pour créer votre réseau et gérer vos modules Z-Wave.
La carte d’extension Razberry se négocie autour de 59€, vous pouvez l’obtenir sur Amazon notamment.
Très petite, elle se loge sans problème dans un boitier Raspberry Pi.
Le point fort de la partie logicielle livrée avec la Razberry est son API web Cette interface de programmation vous permet de créer vos propres programmes, dans le language que vous voulez De manière très synthétique, vous pouvez gérer et piloter vos modules Z-Wave en lançant des requêtes HTTP GET sur votre Raspberry Pi ! C’est vraiment très simple et très souple.
Dans mon prochain article (qui est déjà en préparation) je vous présenterai mon installation Z-Wave composé de cinq modules « prise de courant » pilotés depuis mon smartphone Vous verrez, c’est très simple à mettre en place en quelques lignes de PHP, HTML et JavaScript
Domotique, Internet et sécurité
Si vous vous lancez dans la domotique, il est très important de comprendre les enjeux de sécurité. En effet, si vous voulez « connecter » votre maison à Internet, il faut bien comprendre que votre maison devient, dans une certaine mesure, « pilotable » depuis n’importe où ! Il est donc primordial de vous assurer que votre système est sécurisé pour éviter que des personnes mals intensionnées prennent le contrôle de votre maison !
Je vous propose de lire cette série de trois articles du blog de la société Advens (spécialisée dans la sécurité) qui aborde cette problématique de manière très professionnelle et concrète, autour d’un projet de pilotage d’une chaudière
Parmi les capteurs les plus usités on trouve les télémètres : des senseurs capables de mesurer les distances. Plusieurs technologies peuvent être mises en oeuvre pour mesurer les distances par télémétrie. On trouve ainsi des télémètres optiques (utilisant la lumière, comme les télémètres laser, très précis), des radars (utilisant les ondes radio), des sonar (utilisant les ondes sonores), etc…
Le principe est toujours le même : Il s’agit d’envoyer un signal (lumineux, radio ou sonore) et de mesurer en combien de temps ce signal revient à son point d’origine après avoir « rebondit » sur un obstacle. Lorsqu’on connait la vitesse de propagation de la lumière ou des ondes sonores, on peut déterminer à quelle distance se trouve un objet grâce à la formule connue de tous : vitesse = distance / temps, soit distance = vitesse x temps.
Dans cette article nous allons nous intéresser en particulier aux télémètres à ultrason. Nous allons voir quels modèles choisir et comment les utiliser avec nos Raspberry PI
La mesure du temps
Comme vu précédemment, mesurer une distance par télémétrie, consiste à mesurer le « temps » que met un signal pour aller et revenir. La précision du calcul de la distance dépend donc fortement de la précision de la mesure du « temps« .
Prenons un exemple : Un capteur à ultrason émet un signal sonore qui se propage (dans l’air) à une vitesse de 321 m/s, vers un objet se trouvant à 10 mètres. Le temps que va mettre le signal pour aller et revenir est donc de : 2 x 10 (m) / 321 (m/s) = 0,062 (s) = 62 millisecondes
Il s’agit de « temps » très courts, de l’ordre du millième de seconde. Pour les télémètres laser on parles de nanosecondes (un milliardième de seconde), c’est très rapide :).
Dans notre exemple, si on introduit une erreur de l’ordre de 5% dans la mesure du temps, on obtiendra une distance entre 9,5m et 10,5m, soit 1m d’erreur possible pour un objet positionné à 10m (l’erreur augmentant proportionnellement à la distance). Ce qui est énorme, vous en conviendrez Il est donc impératif d’avoir une mesure du « temps » très précise entre l’émission et la réception du signal.
Temps réel et temps partagé
Dans le cas d’un circuit électronique dit « temps réel« , chaque opération ou calcul réalisé se fait dans un lapse de temps contrôlé et bien déterminé. Dans le cas d’un télémètre, cela signifie qu’entre le moment où le circuit envoie le signal, et le moment où il le reçoit, il est possible de mesurer très précisément le temps qui s’est écoulé en additionnant le temps « utilisé » par toutes les opérations réalisées par le circuit pendant ce lapse de temps.
Dans le cas du Raspberry Pi, qui fonctionne sous Linux (Rasbian par exemple) nous sommes sur un système dit « à temps partagé« . En effet, pour que votre Pi puisse exécuter plusieurs programmes en même temps (ou du moins pour que vous en ayez l’impression), le système d’exploitation « alloue » un certain temps processeur à chaque programme. Quelques microsecondes pour votre navigateur Internet, puis quelques microsecondes pour gérer la souris, puis quelques microsecondes pour votre lecteur de musique, puis à nouveaux quelques microsecondes pour votre navigateur Internet… et ainsi de suite… Ces opérations s’enchaînent tellement rapidement que vous avez l’impression que tout fonctionne en même temps, magique
Le problème avec la télémétrie sur un système à « temps partagé« , c’est qu’entre le moment où le système envoie le signal et le moment où il le reçoit, le système d’exploitation peut décider d’allouer des ressources à d’autres programmes. Le système ne traitera la réception du signal de retour, que lorsqu’il aura terminé toutes les opérations qu’il a entrepris de réaliser entre temps. Le problème, c’est que pendant ce temps, l’horloge continue de tourner, ce qui peut fausser la mesure du temps, et par conséquent, le calcul de la distance
Le choix du télémètre à ultrason
Grâce à l’essor des cartes Arduino, Raspberry Pi et autres BeagleBone, on peut trouver de nombreux télémètres à ultrason, permettant avec plus ou moins de précision, de mesurer des distances jusqu’à une dizaine de mètres. On trouve également des télémètres infrarouge qui fonctionnent sur le même principe, mais leur portée et leur précision son généralement moins bonnes. Ils sont généralement utilisés pour détecter objets très proches, voire détecter un contacte avec un objet.
Pour éviter les problèmes de précision des systèmes à « temps partagé » détaillés précédemment, il convient de choisir des modules dotés de circuits intégrés qui réalisent eux même les calculs de distances. Pour pouvoir l’utiliser directement sur votre Raspberry Pi, vous devrez également veillez à ce qu’il utilise un bus ou un protocole supporté par le GPIO du Pi (I2C, SPI, etc,…).
Le télémètre à ultrason SRF02 répond parfaitement à ce cahier des charges et est disponible pour une vingtaine d’Euros sur Amazon :
SRF02
Ce module « autonome » est parfaitement adapté au Rapsberry Pi. Alimenté en 5V il ne consomme que 4mA et il dispose d’un bus I2C. Le SRF02 permet de mesurer des distances de 16cm à 6m avec une précision de l’ordre de 1 à 2 cm. L’ensemble est très petit (24x20x17 mm), et ne nécessite pas de calibration
Le cône de détection est relativement large ce qui, selon l’usage, peut être un avantage ou un défaut. A noter qu’il existe des télémètres beaucoup plus directifs.
Branchement et configuration du GPIO du Raspberry Pi
Comme pour tous les périphériques I2C, le branchement se fait sur les broches SDA et SCL du GPIO du Pi :
Une fois les branchements effectués, il convient d’activer le support de l’I2C sur le Raspberry Pi. Ceci se fait en deux étapes :
1 – Editez le fichier /etc/modules et ajoutez les deux lignes suivantes :
i2c-bcm2708
i2c-dev
2 – Editez ensuite le fichier /etc/modprobe.d/raspi-blacklist.conf et commentez les deux lignes suivantes (en ajoutant # au début de ces deux lignes) :
# blacklist spi-bcm2708
# blacklist i2c-bcm2708
Pour finir, installez l’outil i2c-tools et redémarrez le Pi :
apt-get install i2c-tools
shutdown -r now
Pour vérifer que la carte est bien reconnue par le Pi, lancez la commande suivante :
i2cdetect -y 1 # pour la révision 2 du Pi
ou
i2cdetect -y 0 # pour la première version du Pi
Le module SRF02 est ici détecté à l’adresse 0x70 Si vous utilisez plusieurs périphériques I2C, vous pouvez changer cette adresse en suivant la procédure décrite dans ce document : SRF02_Technical_Specification.pdf
Il ne reste plus qu’à installer les lib Python nécessaires :
Puisque le SRF02 se charge tout seul de prendre les mesures et de réaliser les calculs, le code est élémentaire, il suffit de lire la valeur retournée par le module dans l’unité de notre choix
Note : D’après le document SRF02_Technical_Specification.pdf, vous pouvez directement extraire la valeur en centimètres, en inches ou en microsecondes
Voici donc un petit script en Python, distance_SRF02.py, qui affiche la distance mesurée en centimètres, toutes les secondes :
#!/usr/bin/python
import smbus, time
i2c = smbus.SMBus(1)
adresse = 0x70
mode = 81 # centimetres
while True:
try:
i2c.write_byte_data(adresse, 0, mode) # lance un "ping" en centimetre
dst = i2c.read_word_data(adresse, 2) / 255 # lit le "mot" de données à partir du registre 2 et divise par 255 pour obtenir un entier (Cf doc technique)
print(dst)
time.sleep(1)
except KeyboardInterrupt:
quit()
Très simple d’utilisation, ce petit module trouvera sa place dans mon drone PiBOADrone en tant qu’altimètre sol basse altitude
Exemples d’utilisations
Altimètre sol basse altitude pour drone
Radar de recul pour voiture OU radar d’avancement pour parking/garage
Dans cet article, nous allons voir comment mesurer la température ambiante avec deux types de sondes thermomètres très différentes : la sonde numériqueDS18B20 et la sonde analogiqueTMP36. Dans les deux cas, il s’agit d’un minuscule composant à trois pattes, dont la résistance des composants internes varie en fonction de la température.
Il faut savoir que le GPIO du Raspberry Pi ne dispose pas d’entrées analogiques, il est par conséquent impossible de mesurer la valeur d’une résistance ou d’un courant directement.
La sonde DS18B20 est, quant à elle, une sonde numérique qui utilise un bus/protocole particulier qui permet communiquer l’information à travers un seul câble (par extension, une seule broche du port GPIO du Pi) ; il s’agit du bus 1-Wire.
Matériel utilisé dans cet article
Pour réaliser ces deux montages, en plus des sondes TMP36 et DS18D20, vous aurez besoin d’une breadboard, de wire jumpers et d’une résitance. Vous pouvez trouver ces composants directement ici :
Sonde analogique TMP36 et ADC MCP3008
TMP36
MCP3008
Alimentée entre 2,7V et 5,5V (parfait pour le Pi qui peut fournir une alimentation de 3V ou 5V), la sonde TMP36 permet de mesurer des températures de -50°C à +125°C avec une précision annoncée entre 0,5°C et 1°C en moyenne. Fonctionnant dans la même plage de tension (2,7V à 5,5V), le convertisseur analogique/numérique MCP3008 dispose de huit entrées, ce qui permet de lire les informations de huit capteurs (de température ou autre). Le MCP3008 dispose d’une interface SPI, nativement supportée par le Pi En outre, il offre de résolution de 10 bits, ce qui va lui permettre de distinguer 2^10 soit 1024 valeurs. Il est important de noter que le MCP3008 permet un échantillonnage beaucoup plus fin (1024 valeurs) que ce que permet de mesurer le TMP36, ce dernier ne sachant distinguer que 50+125/0,5 soit 350 températures différentes (au mieux).
Le schéma ci-dessous montre comment brancher le MCP3008 sur le GPIO du Pi, et comment relier le TMP36 au MCP3008 :
En dehors des fils d’alimentation (en noir et en rouge), le bus SPI du MCP3008 occupe quatre broches sur le GPIO du Pi. La broche centrale (tension de sortie) du TMP36 est directement reliée à une des entrées du MCP3008.
Après les branchements, passons à la partie logicielle
Seul le paquet python-dev est strictement nécessaire pour utiliser l’interface SPI du MCP3008 :
apt-get install python-dev
Les dernières versions de Raspbian ne nécessitent pas de manipulations particulières pour utiliser le bus SPI du GPIO. Si toutefois vous rencontrez des problèmes, il faudra mettre à jour la lib Python rpi.gpio :
Intéressons nous maintenant au fonctionnement du MCP3008 pour comprendre comment extraire la température mesurée par le TMP36.
Le principe est relativement simple : le MCP3008 renvoie une valeur entre 0V et la tension de « référence« (ici 3,3V ou 3300mV car nous avons connecté la broche Vréf du MCP3008 à la broche 3,3V du Pi). Cette valeur (en mV) est codée sur 10 bits (soit 2^10=1024 valeurs possibles) puis envoyée sur le bus SPI. Nous obtiendrons donc un nombre entier entre 0 et 1023. Pour obtenir la valeur en mV, il nous suffit d’appliquer une « règle de 3 » :
mV = valeur * 3300 / 1024
La tension renvoyée par le TMP36 se situe entre 0V pour -50°C et 1,75V pour 125°C, ce qui donne 1,75/(50+125)=0,01V soit 10mV par degré. Pour convertir les mV en degrés Celsius, nous devons donc réaliser le calcul suivant :
t °C = (mV / 10) - 50
(10mV par degré, puis on retire 50 car on part de -50°C à 0V)
Ci-dessous, un petit script Python, temperature_MCP3008_TMP36.py qui réalise toutes ces opérations et affiche la température en °C :
#!/usr/bin/env python
import time
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
# initialise les ports du GPIO
GPIO.setup(24, GPIO.OUT)
GPIO.setup(23, GPIO.IN)
GPIO.setup(18, GPIO.OUT)
GPIO.setup(25, GPIO.OUT)
# lit les donnees SPI du MCP3008 et renvoie un entier entre 0 et 1023
def readspi(mcp3008_input):
GPIO.output(25, True)
GPIO.output(18, False)
GPIO.output(25, False)
commandout = mcp3008_input
commandout |= 0x18
commandout <<= 3
for i in range(5):
if (commandout & 0x80):
GPIO.output(24, True)
else:
GPIO.output(24, False)
commandout <<= 1
GPIO.output(18, True)
GPIO.output(18, False)
bitout = 0
for i in range(12):
GPIO.output(18, True)
GPIO.output(18, False)
bitout <<= 1
if (GPIO.input(23)):
bitout |= 0x1
GPIO.output(25, True)
bitout /= 2
return bitout
# boucle principale qui realise les calculs et affiche le resultat toutes les 5 secondes
while True:
try:
bitout = readspi(0) # lit les donnees de l'entree 0 du MCP3008
mV = bitout * ( 3300.0 / 1024.0) # convertit la valeur en mV
tC = (mV/10.0) - 50.0 # convertit les mV en degre Celsius
tC = "%.1f" % tC # ne garde que une decimale
print(tC)
time.sleep(5)
except KeyboardInterrupt:
quit()
Et voilà Il ne vous reste plus qu’à envoyer cette température à votre dashscreen pour afficher la température ambiante de votre salon
Sonde numérique DS18B20 et bus 1-Wire
DS18B20
Alimentée en 3V ou 5V la sonde numérique DS18B20 offre une précision de 0,5°C, et permet de mesurer des températures entre -55°C et +125°C. Cette sonde utilise un bus 1-Wire qui permet de se passer d’un convertisseur analogique/numérique, et occupe ainsi une seule broche du port GPIO du Pi (en dehors des deux broches d’alimentation). Pour assurer le bon fonctionnement de cette sonde, il convient d’utiliser une résistance dite « pullup » pour appliquer une tension de « référence » à la borne centrale du composant. Dans notre cas, et avec un Pi, il convient d’utiliser une résistance de 4,7k ohm.
Le schéma ci-dessous montre comment brancher la sonde DS18B20 et la résistance sur le GPIO du Pi :
Pour faciliter le montage, vous pouvez souder la sonde et la résistance sur un petit morceau de plaque epoxy :
Passons à la partie logicielle qui est ici très simple. En effet, il suffit de charger les modules 1-wire nécessaires pour voir apparaitre un nouveau périphérique dans le répertoire /sys/bus/w1/devices :
modprobe w1-gpio
modprobe w1-therm
ls -l /sys/bus/w1/devices/
total 0
lrwxrwxrwx 1 root root 0 Dec 3 21:02 28-000005305b19 -> ../../../devices/w1_bus_master1/28-000005305b19
lrwxrwxrwx 1 root root 0 Dec 3 20:59 w1_bus_master1 -> ../../../devices/w1_bus_master1
Ici, ma sonde est détectée avec le numéro 28-000005305b19. Ce numéro est normalement unique et « gravé » en usine directement dans le composant. Si vous utilisez plusieurs DS18B20, vous devriez avoir plusieurs périphériques avec des numéros différents
Si vous lisez le contenu de ce nouveau périphérique, vous devriez obtenir quelque chose de ce type :
La température est directement affichée en degré Celsius t=23625 Ou presque, car il faut tout de même diviser cette valeur par 1000.
Voici donc un petit script temperature_DS18B20.py dont le rôle est de lire le contenu de ce fichier et d’en extraire la température
#!/usr/bin/python
import os, glob, time, datetime
os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')
device_file='/sys/bus/w1/devices/28-000005305b19/w1_slave'
# lit le contenu du peripherique et extrait la temperature puis la divise par 1000
def read_temp():
f = open(device_file, 'r')
lines = f.readlines()
f.close()
temp_string = lines[1].strip()[-5:]
temp_c = float(temp_string)/1000.0
return temp_c
# boucle principale qui affiche la température toutes les 5 secondes
while True:
try:
tC = read_temp()
print(tC)
time.sleep(5)
except KeyboardInterrupt:
quit()
Et voilà, très simple, très économique, et relativement précis
TMP36 vs DS18B20
Par curiosité j’ai réalisé un script qui compare la température mesurée par le TMP36 et le DS18B20 :
Pour faire augmenter la température, j’ai posé un doigt sur chaque sonde. On constate que les deux sondes mesures des températures très proches. Le DS18B20 mesure cependant une température d’environ 0,5°C plus chaude que le TMP36.
Dans tous les cas, on ne peut qu’espérer une précision à 0,5°C. J’ai pu constater que ma station météo ainsi qu’un autre thermomètre de mon appartement affichent des températures similaires, avec des écarts jusqu’à 1°C.
J’ai pu tester le dispositif pendant une semaine sur notre terrain. En mode commando avec une petite pelle et une lampe frontale, tout l’équipement dans un sac noir, je suis allé enterrer le paquet au fond du terrain un dimanche soir, et suis revenu le cherché le dimanche suivant.
J’ai imprimé une petite note explicative sur le dessus de la boite contenant le dispositif avec mes coordonnées, au cas où quelqu’un tomberait dessus…
Après avoir armé le système et synchronisé l’horloge du circuit d’alimentation, j’ai creusé un trou au fond du terrain pour y cacher la boite. La webcam est attachée sur une clôture à environ un mètre du sol. Il n’y a plus qu’à croiser les doigts pour que tout se passe bien… Le lendemain, je devrais recevoir les premières images sur le serveur de monitoring à partir de 8h. Bizarrement, je sens une légère angoisse en laissant tout ce matériel dans la nature :/
Premiers constats
Très encombrant
Avec la grosse batterie 12V de 12Ah du circuit d’alimentation, l’ensemble du dispositif est lourd et volumineux. Cette batterie étant largement sur-dimensionnée, j’ai acheté une batterie 12V de 3,5Ah. Largement suffisante en terme de capacité, cette nouvelle batterie est beaucoup plus compacte et légère. En retravaillant l’agencement des éléments du système, j’ai pu aboutir à un dispositif beaucoup plus petit L’ensemble tient maintenant dans une boite de 25 x 13 x 8,5 cm.
Sous terre, point de 3G !
A hauteur d’homme sur le terrain, je capte 4/5 barres de 3G avec mon smartphone. Si je pose mon smartphone au sol, je ne capte plus de 3G, je passe en EDGE avec seulement 2/5 barres…
C’est pourquoi je n’ai pas enterré le dispositif trop profondemment. Tout juste de quoi le camoufler sous un centimètre de terre et de mauvaises herbes…
A ma grande surprise, le dongle 3G du dispositif captera suffisant de réseau pour pouvoir transmettre les images au serveur de monitoring. De temps en temps, la connexion n’est pas suffisamment bonne, et je ne recoit plus de nouvelles du dispositif…
Dans tous les cas, les images sont stockées sur la carte SD du Pi, donc tout va bien
La rosée du matin
Voilà la première image que j’ai reçu le lundi matin :
Et c’est pareil tous les matins sur toutes les photos prises avant 10h environ… Je suis actuellement en train de tester différentes techniques pour éviter la formation de buée sur l’objectif de la webcam. Je vous en ferai part dès que j’aurai des résultats concluants.
Si vous connaissez des astuces, n’hésitez pas à m’en faire part en commentaire de cet article
Variation de lumière
Comme je m’y attendais, il y a de grosses différences de luminosité d’une photo à l’autre. Entre le soleil et les nuages qui diffusent la lumière puis la retiennent, j’ai parfois des photos surexposées, et parfois des photos très sombres…
Le fait de prendre plusieurs images à la suite pour permettre à la webcam d’ajuster la luminosité et le contraste permet de masquer le problème en partie.
Pour parfaire le résultat, j’ai commandé un filtre polarisant pour apareil photo. J’espère que cela fonctionnera…
De belles photos
Malgré ces petits défauts, le dispositif m’a ramené de belles images comme celle-ci :
Avec des photos comme celle-là, on peut espérer un joli timelapse de la construction de la maison La construction doit débuter dans deux semaines. J’ai donc encore quelques jours pour améliorer le dispositif
Voici un premier aperçu d’un timelapse réalisé sur cette semaine de test. Je reste relativement déçu par la qualité des images :/
Une petite frayeur
Au moment de laisser le système dans la nature, j’ai eu une petite angoisse : « Et si quelqu’un tombe dessus ? », « Et si on me le volait ? »… Bref…
La première journée, le lundi, j’étais scotché au serveur de monitoring pour voir si tout allait bien. De temps en temps, une photo n’arrivait pas (problème de réseau), mais le coup d’après tout rentrait dans l’ordre.
Rien à signaler sur le terrain, personne à l’horizon… Soudain, vers 16h, une camionette apparait sur la photo :
Puis plus rien… Plus d’image… Plus de nouvelles sur le serveur de monitoring…
J’étais persuadé qu’on m’avait piqué le matériel pourtant bien camouflé… Dégouté…
Le lendemain matin à 8h tapante, je reçois un mail du serveur de monitoring, tout va bien