Avec l’hiver et Noël qui approchent, l’idée m’est venue de mettre un peu d’ambiance sur le Mini Pi Dash Screen en faisant tomber de la neige en Python avec PyGame. En rajoutant simplement quelques lignes de code, il est très facile en Python de simuler des flocons de neiges tombant et s’amassant en bas de l’écran.
Je me suis inspiré d’un ancien soft que je faisais tourner sur mes machines il y a longtemps, Xsnow.
Pour implémenter ces flocon qui tombe sur l’écran, le principe est simpliste au possible. Il s’agit tout bêtement de créer une liste de points (représentant chacun un flocon de neige), de leur attribuer à une coordonnée en X et Y sur l’écran, et d’incrémenter de quelques pixels leurs position en Y. Procédons.
Commençons par définir les variables clés :
screen_w = 800 # largeur en px de l'écran
screen_h = 480 # hauteur en px de l'écran
snow_floor_h = 13 # hauteur en px de la couche de neige en bas de l'écran
snow_flakes = 100 # nombre de flocons affichés en même temps
On initialise ensuite PyGame :
pygame.init()
pygame.mouse.set_visible(False)
pygame.display.set_caption('Liberty')
size = [screen_w, screen_h]
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
screen.fill((0, 0, 0))
pygame.display.update()
start_time = 0
frame_count = 1
frame_rate = 10 # avec 10 images par secondes on obtient une chute de neige relativement fluide
On créé ensuite le tableau de flocons « snow_list », en leur attribuant à chacun des coordonnées aléatoires volontairement jusqu’à -10 et +10, par rapport à la largeur de l’écran) pour qu’ils apparaissent à peine en dehors de l’écran. En même temps on initialise un autre tableau « snow_floor » dans lequel on viendra placer les flocons qui tombent au moment où ils touchent le sol.
snow_list = []
snow_floor = []
for i in range(snow_flakes):
x = random.randint(-10, screen_w+10)
y = random.randint(-10, screen_h+10)
snow_list.append([x, y])
snow_floor.append([-10, -10])
Enfin, dans la boucle principale,
while True:
# on remplit l'écran de noir
screen.fill((0, 0, 0))
# on dessine ensuite ce qui constitue la base de la couche de neige en bas de l'écran
snow_floor_y=screen_h-snow_floor_h
pygame.draw.rect(screen, WHITE, pygame.Rect(0, snow_floor_y, screen_w, snow_floor_h))
# Ensuite, dessine les flocons un par un et on incrémente leurs coordonnées
for i in range(len(snow_list)):
# un simple cercle de 2px pour chaque flocons
pygame.draw.circle(screen, WHITE, snow_list[i], 2)
# les coordonnées en X sont aléatoirement modifiées entre -2 et +2 px pour éviter d'avoir une chute trop verticale.
# si vous voulez ajouter un effet de vent latéral, vous pouvez par exemple modifier la coordonnées en X de -2 à +4 par exemple.
snow_list[i][0] += random.randint(-2, 2)
# les coordonnées en Y sont aléatoirement modifiées de +1 à +4 px pour avoir des vitesses de chute différentes et obtenir un rendu plus réaliste
snow_list[i][1] += random.randint(1, 4)
# si un flocon touche le sol, alors réinitialise s'est coordonnées pour qu'il reparte en haut de l'écran
if snow_list[i][1] >= snow_floor_y:
# coordonnée en X aléatoire sur toute la largeur de l'écran
snow_list[i][0] = random.randint(-10, screen_w+10)
# coordonnée en Y à -10 pour redémarrer à peine plus haut que le bord de l'écran
snow_list[i][1] = -10
# on copie les coordonnées du flocon dans la liste des flocons à afficher à la surface du sol
snow_floor[i][0] = snow_list[i][0]
snow_floor[i][1] = snow_list[i][1]
# on dessine ensuite tous les flocon qui sont au sol
pygame.draw.circle(screen, WHITE, snow_floor[i], 2)
frame_count += 1
clock.tick(frame_rate)
pygame.display.flip()
Et voilà Il vous suffit d’implémenter ce morceau de code dans le celui du Mini Pi Dash Screen et le tour est joué !
Perso, j’aime beaucoup le résultat et je suis curieux de voir comment vous allez le tweaker et l’améliorer.
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.
MàJ déc 2016 : changement de nom de domaine pour le projet qui devient www.cam-aero.eu
Il fait beau et chaud, les vacances d’été ne sont plus très loin. Le temps parfait pour les activités de plein air. Ca tombe bien, aujourd’hui je vais vous présenter un projet réalisé pour le sitewww.cam-aero.eu, en partenariat avec MagdiBlog.fr, qui ravira les amateurs d’aéronautique de loisir
L’objectif de ce projet est de doter tous les aérodromes d’un module caméra qui prend des photos de la piste et de la météo ambiante à intervalles réguliers tout en incrustant la date, l’heure et les informations météorologiques locales (telles que METAR, TAF, SIGMET) dans l’image.
Voici un aperçu d’une image d’un aérodrome dans la région de Brest :
L’ensemble des images de tous les aérodromes équipés sont collectées et stockées sur un serveur central. Toutes les images et informations météorologiques locales sont ensuite consultables par tous les membres ; ce qui leur permet de mieux préparer leurs vols, par exemple, en connaissant l’état de l’aérodrome de destination.
Un système collaboratif simple, économique, à la porté de tous (Le module s’installe sur une fenêtre avec une ventouse et nécessite une simple connexion Internet. L’installation du logiciel et sa configuration se font en une seule ligne de commande), qui permettra à tous les aérodromes de partager une vue de leur piste et leurs informations METAR facilement
Le système complet est réalisé avec des Raspberry Pi, sans composants particuliers :
CanardPC vient de sortir un numéro spécial dédié au Raspberry Pi et Arduino et à l’électronique en général. Je vous invite à le choper tant qu’il est toujours dispo chez votre libraire
Je viens de changer de serveur d’hébergement pour MagdiBlog.fr, aussi, veuillez m’excuser pour les coupures qui ont pu avoir lieux ces dernières 24h. Il se peut également que certains commentaires aient été perdus lors de la migration, mais c’est pour la bonne cause, le site devrait être beaucoup réactif à présent
Je profite de ce billet pour vous annoncer que le projet Pi BOAt n’est pas mort, les articles paraitront à partir de la rentrée
En outre, je prépare un article sur la partie vidéo, l’utilisation d’objectifs sur la Pi Camera ainsi que sur les différentes manières d’utiliser le module caméra sur le Pi
Profitez bien des quelques jours d’août qu’il nous reste,
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
Vous avez été près de 400 participants à ce concours organisé à l’occasion des 3 ans de magdiblog.fr !
Félicitations à Philippe alias ay15ho11 qui a été tiré au sort grâce au plugin Comment Contest
Philippe, je vous invite à me contacter en utilisant la page contact du site pour que je puisse vous faire parvenir vos cadeaux
Merci à toutes et à tous pour votre participation Je vous souhaite un excellent week end et un très bon été à venir !
Olivier
MàJ du 18 mai 2016 :
Plus que 48 heures pour participer
On est passé de 190 à plus de 270 participants dans les dernières 24h !
Bonne chance à toutes et à tous
MàJ du 10 mai 2016 :
Le tirage aura lieu le vendredi 20 mai à 12h00 !
Plus de 160 participants à l’heure actuelle !
Bonne chance à toutes et à tous
Bonjour à toutes et à tous,
Comme annoncé le mois dernier, à l’occasion des 3 ans du blog et du million de pages vues, j’ai le grand plaisir d’ouvrir le jeu concours organisé pour fêter l’événement !
Pour participer c’est très simple, il vous suffit de poster un commentaire sur cet article.
Le gagnant sera tiré au sort parmi les auteurs de commentaire de cet article, résident en France, le vendredi 20 mai à 12h00 (midi).
N’oubliez pas de bien vérifier votre adresse email afin que je puisse vous contacter si vous êtes tiré au sort.
Inscrivez vous à la newsletter (en haut à droite du site) pour vous tenir informé des résultats du concours, de la suite du projet Pi BOAt ainsi que des projets à venir
Le 29 février 2016, soit exactement quatre ans après la sortie du tout premier Raspberry Pi A, la fondation annonce le Raspberry Pi 3. Ils aiment bien les années bissextiles à la fondation Raspberry Pi, c’est comme ça !
Grâce à mon partenaire Kubii.fr, j’ai pu tester ce dernier modèle qui, n’ayons pas peur des mots, commence sérieusement à envoyer du lourd ! J’en profite pour envoyer une bise à Julie de l’équipe Kubii.fr
La même base
La fondation Raspberry Pi semble porter une attention particulière à la rétro-compatibilité des nouveaux modèles avec les accessoires destinés aux RPi plus anciens et on apprécie !
Aussi, le PCB est strictement identique à celui du Raspberry Pi 2. Le GPIO de 40 broches est également le même que sur les modèles B+, 2, A+ et Zero assurant ainsi la compatibilité avec la plupart des cartes filles existantes et que vous pouvez trouver dans la rubrique cartes d’extensions sur Kubii.fr.
Le Raspberry Pi 3 est, comme sont prédécesseur, doté des ports série caméra et écran, respectivement CSI et DSI, de quatre ports USB, d’un port Ethernet, HDMI et jack. Le format micro-SD est également conservé pour la carte système. Pas de bouleversement de ce côté là, donc.
Comme vous pouvez le voir sur les deux photos ci-dessous, à l’œil nu, difficile de différencier un RPi 3 d’un RPi 2.
Un processeur boosté
En revanche, côté processeur, on passe du Cortex-A7 quad-core cadencé à 900MHz qui équipe le RPi 2, à un ARMv8 quad-core 64-bit qui ronronne à 1.2GHz. L’écart peut paraître faible présenté comme ça, mais le Raspberry Pi 3 est beaucoup plus réactif que le RPi 2 avec un gain effectif de l’ordre de 50%. Le passage au 64-bit n’apporte en soit pas grand chose.
Sous Kodi, on gagne en réactivité (même si c’était déjà très fluide avec le RPi 2). L’écart de réactivité se sent également sur une utilisation desktop.
Alors bon… à 1,2GHz dans un boîtier fermé et sans ventilo, ça commence sérieusement à chauffer. L’installation d’un petit dissipateur thermique sur le SoC est presque indispensable. En outre, n’espérez pas faire de l’overclocking sans prévoir une solution de refroidissement adéquate. Je vous laisse découvrir l’article dédié à ce sujet publié sur minimachines.net.
Précisons également que la bête consomme également plus d’énergie (ah bah oui, on n’a rien sans rien !). La fondation préconise l’utilisation d’une alimentation pouvant délivrer 2,5A sur 5V. J’insiste toujours sur ce point, la qualité de votre alimentation joue un rôle très important sur la durée de vie du RPi et de la carte SD, qui est TRES sensible. La plupart des problèmes rencontrés sur les RPi viennent d’une alimentation de piètre qualité. N’hésitez pas à investir dans un bon transfo et à viser toujours un plus haut que les préconisations. Pour le RPi 3 on choisira donc une alim Aukru de 3A, marque dont la réputation n’est plus à faire.
Le GPU reste cependant le même que sur tous les autres Raspberry PI, à savoir un Broadcom VideoCore IV. Dommage car on aurait aimé pouvoir visionner des vidéos en 4K ou au moins pouvoir profiter du h265, ce qui aurait fait du Raspberry Pi 3 le média tank le plus puissant et le plus polyvalent du marché. Ce sera sans doute pour la prochaine fois
Note : J’ai testé pour vous la lecture d’une vidéo en 4K avec la dernière mouture de Kodi… Écran noir, le RPi freeze, bref… va falloir se contenter du 1080p/h264 encore quelques temps…
Niveau mémoire vive, on reste également sur 1GB de RAM. Ils auraient pu pousser à 2GB pour plus de confort sur une utilisation desktop, mais la fondation respecte les contraintes de coût de fabrication qu’elle s’est fixée, lui permettant ainsi de proposer le RPi 3 au même prix que le RPi 2 à sa sortie.
Du WiFi et du Bluetooth
Outre un processeur plus véloce, le RPi 3 arrive avec deux caractéristiques vraiment, VRAIMENT, intéressantes ! Effet, le RPi 3 embarque sur son PCB une puce WiFi 802.11n et une puce Bluetooth 4.1.
Plus besoin, donc, d’acheter un dongle USB qui faisait grimper l’addition d’une quinzaine d’euros, et ça, c’est cool ! En plus, ça libère un port USB, top !
Faut il acheter le Raspberry Pi 3 ?
Oui, et pour deux raisons. La première étant que le Raspberry Pi 3 est le modèle le plus puissant à ce jour et c’est toujours appréciable de profiter d’une réactivité accrue.
La seconde est que je vous encourage à soutenir la fondation Raspberry Pi pour qu’ils puissent continuer leur travail et proposer des Pi toujours plus puissants et complets pour moins de 50€. Bravo et merci à eux !
Aujourd’hui, MagdiBlog.fr fête ses 3 ans d’existence. Lancé en mars de 2013 avec les projets PiTimeLapse, PiCarJukeBox et PiHomeDashScreen le blog a atteint en mars 2016 le million de pages vues !
Je tiens à vous remercier lectrices (si si, il y en a !) et lecteurs de MagdiBlog.fr pour votre soutien, votre bonne humeur et votre enthousiasme ! J’espère vous voir encore nombreux à suivre l’actualité du Raspberry Pi et les nombreux projets à venir tels que le Pi BOAt.
Pour fêter l’événement et parce que je vous aime bien, il y aura très bientôt un tirage au sort avec un Raspberry Pi 3 à gagner !
Dans l’attente, profitez du soleil et inscrivez vous à la newsletter pour ne pas rater le tirage au sort.
Je n’ai pas pu résister, ce module radar de surface me faisait vraiment trop triper
Au menu, de l’I2C pour le télémètre ultrason SRF02, du ServoBlaster pour le pilotage du servo moteur, du Python pour orchestrer tout ça, et beaucoup de JavaScript et d’HTML 5 (canvas) pour afficher un bel écran radar
Principe de fonctionnement
Un radar c’est quoi ? C’est un truc qui envoi des ondes (sonores, lumineuses, électromagnétiques) et qui attend un retour de cette onde. Si retour il y a, c’est que l’onde a rebondi sur un objet, en mesurant le temps de retour de l’onde, on en déduit à quelle distance se trouve l’objet. En répétant l’opération tout en faisant tourner le radar dans toutes les directions, on peut détecter tous les objets présents aux alentours et les représenter sur un écran
Donc, prenez un capteur à ultrason tel que le SRF02, faites le tourner sur lui même à l’aide d’un servo moteur, et vous avez votre radar
A chaque position d’angle du servo moteur, on note la distance mesurée par le télémètre, on enregistre tout ça dans un registre pour ensuite pouvoir l’afficher. On répète la manip à l’infinie pour avoir un balayage continu
Bien entendu, le temps de réponse et la qualité de mesure des télémètres à ultrason n’étant pas extra-ordinaires, il ne faut pas s’attendre à un haut niveau de précision. Mais, le résultat est, comme vous allez le voir, plus que satisfaisant De plus, il ne faut pas oublier que nous sommes ici pour apprendre et découvrir des principes de fonctionnement. Si votre budget vous le permet, vous pourrez remplacer le télémètre à ultrason par un télémètre laser, et là, vous aurez un radar de surface très précis
Matériel, GPIO et branchements
Au départ, je voulais utiliser le module PCA9685 de chez Adafruit pour piloter le servo moteur, comme dans cet article. Finalement, après avoir testé l’excellente lib ServoBlaster, j’ai décidé de me passer totalement de cette carte et de brancher le servo directement sur le Pi
Au final, j’utilise donc uniquement un télémètre SRF02 et un servo moteur Futaba en les branchant sur le GPIO d’un Pi A+, sans carte intermédiaire
Niveau branchement, rien de plus simple, le télémètre se connecte sur les broches I2C du GPIO comme expliqué dans cet article : GPIO – Télémètre à ultrason SRF02
Pour le servo moteur, une seule broche suffit. Nous utiliserons une alimentation séparée pour le servo dont vous pouvez voir le convertisseur de tension sur la droite de la photo ci-dessous.
Je ferai un article dédié à cet écran très prochainement
Logiciel, Scripts et affichage
L’architecture logicielle du Pi BOAt n’est pas encore définitive mais le principe général est le suivant :
Chaque module est piloté par un script Python dédié
Le script Python inscrit ou lit des données dans un registre au format JSON
Une page HTML est mise à disposition grâce à un mini serveur web en Python
Un script JavaScript lit ou écrit dans le registre et gère l’affichage dans la page web
Note : Pour info, à l’heure où je réalise ce prototype, j’utilise un Raspberry Pi A+ avec une Raspbian Lite Jessie (2015-11-21).
script Python radar.py : gestion du servo et du télémètre à ultrason
Pour piloter le servo moteur, nous utiliserons la lib ServoBlaster qui fonctionne très bien et très simplement
Pour l’installer, rien de plus simple, faites un clone du dépôt GIT suivi d’un make pour compiler les sources :
git clone https://github.com/richardghirst/PiBits
cd ./PiBits/ServoBlaster/user/
sudo make servod
Il convient enseuite d’activer l’I2C pour pouvoir utiliser le télémètre SRF02. Ceci se fait, à présent, très simplement via la commande raspi-config
Ci-dessous, le script python radar.py dont le rôle est de faire aller et venir le servo d’un extrême à l’autre en continu, tout en prenant les mesures de distance avec le télémètre. A chaque position du servo on associe une distance mesurée, et on enregistre le tout dans un fichier radar.json.
Il y a un paramètre set_pas que vous pouvez ajuster en fonction de la finesse des mesures que vous souhaitez réaliser et de la capacité de votre servo moteur. Pour ma part, le servo moteur dont je dispose n’a une course que de 200 degrés environ. Le pas est converti en pourcentage de cet angle. En choisissant un pas de 1, je prendrais donc 100 mesures sur 200 degrés, soit une mesure tous les 2 degrés d’angle.
Bien entendu, plus vous augmentez le nombre de mesures, plus le balayage sera lent. Après quelques essais, je pense qu’il vaut mieux prendre moins de mesures mais avoir un balayage plus rapide. Une mesure tous les 10 degrés d’angle est largement suffisante pour détecter les objets aux alentours et offre un balayage très rapide.
Ceci est d’autant plus vrai avec un télémètre à ultrason dont le cône de détection est relativement large (plus de 30 degré pour le SRF02). Avec un télémètre laser en revanche, il serait plus pertinent d’avoir un balayage plus fin pour avoir des mesures très précises.
#!/usr/bin/python
import RPi.GPIO as GPIO
import smbus, time, os, srf02
radar_data_file = "/home/pi/www/data/radar.json"
data = []
set_pas = 1
fo = open(radar_data_file, "w")
fo.write(str(data));
fo.close()
nb = int((100/set_pas)+1)
for num in range(0,nb):
data.append(0);
# SRF02
s = srf02.srf02()
# SERVO
os.system("sudo /home/pi/PiBits/ServoBlaster/user/servod")
p_min = 0
p_mid = 50
p_max = 100
p = p_min
pas = set_pas
while True:
try:
if p >= p_max:
pas = -set_pas
if p <= p_min:
pas = set_pas
p = p + pas
os.system("echo 0="+str(p)+"% > /dev/servoblaster")
#time.sleep (0.1)
dst = s.getValue()
idx = int((100-p)/set_pas)
print(str(p)+' - '+str(idx)+' - '+str(dst))
data[idx]=dst
fo = open(radar_data_file, "w")
fo.write(str(data));
fo.close()
except KeyboardInterrupt:
os.system("echo 0=50% > /dev/servoblaster")
quit()
En exécutant ce script, vous obtiendrez ce résultat :
script JavaScript et page HTML
C’est là que ça devient réellement fun car on va voir le résultat s’afficher à l’écran
Le principe est relativement simple puisque nous avons une simple page web radar.html qui contient deux canvas. Un pour dessiner le fond du radar et un pour afficher les points correspondant aux objets détectés.
Enfin, le script le plus important, en JavaScript, radar.js.
Quelques explications s’imposent. Dans un premier temps, le script se charge de dessiner le fond du radar dans le premier canvas. Puis, une fonction appelée toutes les 500ms est chargée de lire le registre radar.json, d’en extraire les données et de dessiner les points correspondants sur le deuxième canvas.
Ce script contient quatre paramètres qu’il convient d’ajuster en fonction de vos besoins :
radar_width : largeur et hauteur en pixel du radar affiché dans la page web
max_range : distance maximale en centimètre affichable sur le radar (la distance maximale théorique du SRF02 est de 6 mètres, en pratique, 4 mètres soit 400 cm, c’est bien)
grid_step : pas de la grille radar en centimètre (permet une meilleure lisibilité des distances)
angle_range : largeur du balayage en degré (200 degrés dans mon cas)
/**********************/
/* paramètres */
/**********************/
var radar_width = 500; // taille du radar en px
var max_range = 400; // distance max en cm
var grid_step = 50; // pas de la grille en cm
var angle_range = 200; // largeur du balayage en degré
/**********************/
Math.radians = function(degrees) {
return degrees * Math.PI / 180;
};
var radar_timeout;
var radar_back, radar_back_ctx;
var radar_1, radar_1_ctx;
var radar_radius = radar_width/2; // rayon du radar en px
var range_ratio = radar_radius/max_range; // ratio px/cm
var start_angle = -Math.radians((angle_range/2)+90);
var end_angle = -Math.radians(90-(angle_range/2));
function measureConvert (nb_measure, pos, dst) {
if(dst > max_range) { dst = max_range; }
var angle_deg = -90-(angle_range/2)+Math.round((angle_range/(nb_measure-1))*pos);
var angle_rad = Math.radians(angle_deg);
var dst_px = Math.round(dst*range_ratio);
var x = Math.round(dst_px*Math.cos(angle_rad)+radar_radius);
var y = Math.round(dst_px*Math.sin(angle_rad)+radar_radius);
var coor = {x:x, y:y, angle:angle_deg}
return coor;
}
$(function() {
console.log( "radar ready !" );
initRadar ();
drawRadar ();
});
function getRadarData () {
var data;
$.ajax({
async : false,
type: "GET",
url: 'data/radar.json',
cache: false,
dataType: "json",
success: function (result) {
data = result;
}
});
return data;
}
function initRadar () {
/**********************/
/* Radar Background */
/**********************/
radar_back = document.getElementById("radar_back");
radar_back_ctx = radar_back.getContext("2d");
// background
radar_back_ctx.beginPath();
radar_back_ctx.arc(250,250,250,0,Math.PI*2,true);
radar_back_ctx.fillStyle = "#000000";
radar_back_ctx.fill();
// center
radar_back_ctx.fillStyle = "#FFFFFF";
radar_back_ctx.fillRect(249,249,2,2);
// grid
radar_back_ctx.strokeStyle = "#888888";
radar_back_ctx.lineWidth = 1;
var grid_radius = grid_step;
while(grid_radius < max_range) {
var grid_radius_px = Math.round(grid_radius*range_ratio);
radar_back_ctx.beginPath();
radar_back_ctx.arc(250,250,grid_radius_px,start_angle,end_angle,false);
radar_back_ctx.stroke();
grid_radius = grid_radius+grid_step;
}
/**********************/
/* Radar Layer 1 */
/**********************/
radar_1 = document.getElementById("radar_1");
radar_1_ctx = radar_1.getContext("2d");
}
function drawRadar () {
console.log('drawRadar');
var measures = getRadarData();
var nb_measure = measures.length;
radar_1_ctx.clearRect(0, 0, radar_1.width, radar_1.height);
radar_1_ctx.fillStyle = "#00FF00";
radar_1_ctx.strokeStyle = "#00FF00";
radar_1_ctx.lineWidth = 1;
radar_1_ctx.beginPath();
for(var i = 0; i < measures.length; i++) {
var measure_px = Math.round(measures[i]*range_ratio);
var coor = measureConvert (nb_measure, i, measures[i]);
radar_1_ctx.fillRect(coor.x-1,coor.y-1,3,3);
if(i==0) {
radar_1_ctx.moveTo(coor.x,coor.y);
}
else{
radar_1_ctx.lineTo(coor.x,coor.y);
}
//console.log (i+" - dst "+measures[i]+" - dst_px "+measure_px+" - x : "+coor.x+" - y : "+coor.y+" - angle : "+coor.angle);
}
// radar_1_ctx.stroke();
radar_timeout = setTimeout("drawRadar()", 500);
}
Pour que la page HTML et le script JavaScript soient accessibles via un navigateur, il convient de les publier grâce à un serveur web (autrement appelé serveur de publication web). Inutile de sortir l’artillerie lourde en installant Apache, nous pouvons mettre en place un serveur web minimaliste grâce une petite commande Python :
python -m SimpleHTTPServer
Et voilà ce que ça donne :
J’ai fais ce test sur une table, sur des distances très courtes (moins de 1 mètre). On distingue bien les trois objets sur l’avant et la gauche du radar. Les points qui apparaissent tout à droite correspondent au dossier d’une chaise qui était contre la table
On observe quelques artefacts inhérents à ce type de télémètre à ultrason. Ce qui confirme l’intuition évoquée plus haut qui dit qu’il vaut mieux avoir un balayage plus rapide quitte à être moins précis
Avec un servo capable de faire un balayage à 360 degrés, ou un petit système de démultiplication, nous pourrions afficher un écran radar complet en modifiant le paramètre angle_range. Encore mieux, avec deux télémètres placés dos à dos sur le servo moteur, on pourrait faire un balayage rapide à 180 degrés tout en ayant une détection à 360 degrés C’est probablement ce que je ferai sur la version finale du Pi BOAt.
Voilà pour ce premier module du Pi BOAt qui expose un principe qui peut être utilisé dans de nombreux autres projets.
Guillaume, à l’initiative du Diskio Pi, m’a contacté il y a quelques temps pour me présenter son projet et le moins que je puisse dire, c’est que j’ai été impressionné par son ambition !
Une « plateforme » sous forme de tablette qui peut accueillir un Raspberry Pi 2 ou un Odroid XU4, et qui dispose de tout ce qu’il faut pour l’exploiter : un écran tactile HD, un ampli audio et des hauts parleurs, une batterie, un hub USB. Du plug’n’play pour nos Raspberry Pi
Il s’agit d’un projet open-source hardware qui promet une ouverture sur une infinité de possibilités, et ça, c’est cool
Voici une vidéo de présentation du concept :
A l’origine, le prototype a été réalisé avec une carte Orange Pi. Un écran 17′ a été utilisé pour permettre un rapport épaisseur/surface le plus petit possible, ainsi qu’une surface de travail agréable pour un usage « desktop ». Un indicateur de batterie est présent, avec 5 leds et un bouton pour tester.
Le Raspberry Pi est placé dans un compartiment amovible qui permet l’accès aux différentes entrées/sorties (HDMI, audio, USB, Ethernet…).
Cerise sur le gâteau, le port GPIO reste accessible, et le hub USB intégré permet de brancher facilement des périphériques externes comme un clavier, une sourie ou un disque dur.
L’idée est de viser une compatibilité avec un maximum de cartes et la possibilité d’intégrer des shields annexes tels que des accéléromètres, capteurs de températures, etc…
Pour les fan de domotique, pour qui le DiskioPi peut être un excellent contrôleur, Guillaume prévoit un support mural et une alimentation en POE+ J’ai envie de l’ambrasser
Pour le moment, ce projet n’est pas encore financé, mais de nombreux indicateurs montrent que la demande est là, surtout auprès de la communauté de la domotique libre.
Le porteur du projet, Guillaume, attend avec impatience vos retours du songage qui est actuellement disponible à cette adresse : http://goo.gl/forms/nzDF3fRlBN
Dès qu’un second prototype sera prêt, un crowfunding sera mis en place courant 2016.
Comme vous le savez, je soutiens les initiatives françaises autour des nouvelles technologies Iziproto est une startup strasbourgeoise qui a développé un driver software permettant d’interfacer nombre de capteurs et de faire fonctionner les modèles de régulation sur Raspberry Pi sans effort.
À l’occasion du lancement du projet, Iziproto organise un concours de projet Raspberry Pi à poster sur le groupe facebook Iziproto, avec à la clef une imprimante 3D.
Moi je dis, bravo !Gagnez une imprimante 3D avec Iziproto !
Pour gagner, il faut vous inscrire sur le groupe Facebook et poster votre meilleur projet Raspberry Pi – vidéo ou tuto – , et le projet le plus commenté gagnera une imprimante 3D xyz Da Vinci 1.0 ! Une licence Matlab Home ainsi que des licences Iziproto sont également en jeu.
Pour information, Iziproto est une plateforme de management de Raspberry Pi, qui permet d’interfacer les capteurs Adafruit et de déployer les modèles C ou Python sur la Raspberry Pi facilement, sans commandes Linux. Pour plus d’infos : www.iziproto.com.
M. Chapao, dont le slogan commence par « Je réfléchis beaucoup, je concrétise… autant que faire se peut ! », devrait songer à réfléchir par lui même et à concrétiser ses propres projets.
Alors que j’encourage la reprise de mon travail et que celui ci serve d’inspiration, je trouve vraiment moyen que ce monsieur se permette de pomper tel quel le contenu de mon projet.
Mais ce que je trouve vraiment inadmissible, c’est qu’il se permette de participer à concours avec le travail d’un autre, quand bien même la source serait citée !
Aux partenaires de ce concours que sont OuiAreMakers.com, Framboise314.fr et Kubii.fr, je souhaite exprimer ma déception et mon indignation. Ce concours devrait récompenser l’originalité, l’inventivité et le travail des porteurs de projet, vous auriez pu filtrer ce plagiat au lieu de lui décerner un prix…
Après l’annonce de ce nouveau projet Pi BOAt – Drone marin fin novembre, entrons aujourd’hui dans le vif du sujet
Le Pi BOAt est composé d’une multitude de modules (moteurs, gouvernails, caméra, radar…). Je ferai un article dédié pour chaque module, ce qui vous permettra d’utiliser les explications faites sur un module pour un autre projet. Je ferai également en sorte que l’ensemble reste fonctionnel même si tous les modules ne sont pas présents. De cette manière, vous pourrez reproduire le Pi BOAt chez vous, en ne sélectionnant que les modules qui vous intéressent
D’autres modules pourrons être ajoutés par la suite sans bouleverser le fonctionnement global du Pi BOAt.
Ci dessous, la liste des modules que je vais implémenter dans le Pi BOAt et qui feront chacun l’objet d’un article dédié. N’hésitez pas à soumettre vos idées et remarques
Moteurs
La propulsion du Pi BOAt sera assurée par deux moteurs DC pilotés par un circuit intégré L293D (pont H). Ce circuit intégré permet de gérer le sens et la vitesse des deux moteurs.
Gouvernails
Les gouvernails seront quand à eux animés par un servo moteur. Nous nous inspirerons du travail réalisé sur les servos moteurs détaillé dans cet article : MagdiBlog – GPIO et servos moteurs
Note : Nous utiliserons deux autres servos moteurs pour le pilotage de la caméra et du radar. Pour faciliter la gestion de plusieurs servos moteurs avec le Pi, nous utiliserons la carte PCA9685 de chez Adafruit.
Caméra
La caméra servira à piloter le Pi BOAt avec un retour d’image en temps réel. Nous pourrions nous limiter à l’utilisation du module Pi caméra fixe, mais nous allons y ajouters deux composants, un stabilisateur mécanique (pour stabiliser l’image) et un servo moteur pour pouvoir orienter la caméra à 360°.
Radar
Sans doute le module le plus fun à réaliser Nous utiliserons le télémètre à ultra-son SRF02, monté sur un servo moteur pour avoir un balayage à 360° et ainsi obtenir une « carte » des obstacles présents autours du bateau. Rien que d’en parler, ça m’éclate
Après moultes réflexions, j’ai décidé que le lien radio se fera par WiFi, tout simplement. Il y a de nombreux pour et contre sur ce choix et je serai ravi d’en discuter avec vous. Pour ma part, le gros avantage du WiFi, c’est qu’on peut y faire passer toutes les infos nécessaires au pilotage du bateau (images temps réels, info de guidage, position, etc…). Le second gros avantage de ce choix est que le bateau pourra être piloté par n’importe quel device équipé d’une puce WiFi (PC portable, tablette, smartphone…).
Enfin, ce module pourra être facilement remplacé par un module 3G/4G si le coeur vous en dit
GPS
Parce qu’il est intéressant de pouvoir suivre l’évolution du bateau sur une carte et puisqu’il sera question de développer des fonctions de retour automatique au port, nous embarquerons un module GPS à bord du Pi BOAt
Malgré tout le soin apporté à la confection de la coque du bateau, les voies d’eau sont toujours possibles. Pour éviter les catastrophes et ramener rapidement le bateau au port en cas d’infiltration d’eau, nous allons mettre en place un système très simple de détection d’eau.
Alimentation
Nous allons ici gérer l’alimentation des moteurs et servos moteurs ainsi que l’alimentation du Raspberry Pi qui pilotera l’ensemble.
A l’heure actuelle, je pense faire deux circuits d’alimentation différents, un pour les moteurs et un pour le Pi. Je pense également mettre en place un système d’alimentation de secours afin d’éviter de sortir les palmes pour aller chercher le bateau au milieu d’un lac
Pour les moteurs nous utiliserons probablement un petit accu plomb. Pour le Pi, nous utiliserons certainement une batterie Li-Ion 5V. A voir quelle sera la capacité d’emport du bateau en terme de poids.
La partie la plus importante du projet, le Raspberry Pi, dont le rôle sera de faire fonctionner tous les autres modules ensembles et piloter le bateau.
Je ne suis pas encore fixer sur certains aspects, j’hésite encore à utiliser un Pi 2 B (le plus performant) pour gérer tous les modules, ou utiliser plusieurs Pi Zero (un pour les moteurs et le gouvernail, un pour les systèmes radar, gps, gyro, température, détecteur d’eau et un Pi A+ pour la caméra et la télémétrie.
Je ferai un test avec un Pi 2 B pour voir si il peut gérer l’ensemble des modules sans saturer.
Coque et structure
Une fois que tous les modules seront opérationnels, j’attaquerai la construction de la coque et de la structure du bateau. Je suis totalement novice dans ce domaine et même si je me documente sur le sujet depuis plusieurs mois maintenant, je lance un appel à l’aide à tous ceux qui peuvent m’aider ou me donner des conseils
Je suis notamment à la recherche de plans de coque, pour un bateau d’environ 1m à 1m20 de long
Pour l’instant, la taille et l’allure générale du Pi BOAt ne sont pas encore définies. Cependant, j’aimerai approcher quelque chose qui ressemble au design des frégates FREMM : https://fr.wikipedia.org/wiki/Classe_Aquitaine
La suite
Dans le prochain article, je détaillerai l’architecture logicielle mise au point pour donner vie au Pi BOAt puis j’attaquerai un par un l’ensemble des modules pré-cités.
N’hésitez pas à soumettre vos idées de modules et à donner votre avis sur les modules existants, leur fonction et leur conception.
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
Pour participer à ce concours et peut être gagner l’un des nombreux lots en jeu, il vous suffit de vous inscrire sur la plateforme OuiAreMakers.com et d’y publier le tutoriels complet de votre projet.
La vidéosurveillance est un sujet qui intéresse beaucoup de monde. Alors que les solutions « clé-en-main » vendues sur le marché nécessitent un budget élevé, de nombreux projets plus abordables ont vu le jour avec l’avènement du Raspberry Pi.
Pour ceux qui souhaitait une solution un peu plus « packagée » et avec la détection de mouvement (élément essentiel de la vidéosurveillance), il restait Motion, un logiciel de vidéosurveillance sous Linux dont le support sur Raspberry Pi n’était pas évident (très gourmand en ressources, support du module caméra du Pi non immédiat…).
Aujourd’hui, je vous présente Kerberos.io qui est un logiciel de vidéosurveillance spécifiquement développé pour le Raspberry Pi Près à l’emploi, il suffit de télécharger l’image disponible sur le site et de la calquer sur une carte SD (exactement comme pour Raspbian) et ainsi transformer un Pi en caméra de surveillance (A noté qu’il n’existe pas, pour l’instant de paquet .deb près à l’emploi).
Optimisé pour le Pi et parfaitement compatible avec le module caméra du Pi, Kerberos.io est LA vidéosurveillance clé-en-main pour Raspberry Pi !
Kerberos.io est doté d’une interface web totalement responsive (compatible avec les smartphones et tablettes), épurée et moderne.
Cette interface web vous permettra bien entendu d’avoir les images en temps réel, mais vous présentera également un ensemble de statistiques concernant les événements détectés. Vous pourrez ainsi avoir une trace d’une activité détectées par la caméra.
Il est également possible de déclencher un certain nombre d’opérations lorsqu’un mouvement est détecté comme sauvegarder les images, agir sur le port GPIO, envoyer des requêtes, etc… Enfin, vous pouvez visualiser plusieurs caméras sur une interface web grâce à la fonctionnalité « cloud ».
Pour plus d’info sur kerberos.io, je vous invite à consulter le site officiel : https://kerberos.io/
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 :
Alors qu’il est très facile de distinguer un modèle A d’un modèle B en regardant le PCB, il est très difficile de faire la différence entre les 8 modèles B actuellement en circulation !
La commande suivante vous donnera les informations concernant le processeur de votre Pi :
cat /proc/cpuinfo
Voici ce que me retourne cette commande sur un de mes Pi :
Processor : ARMv6-compatible processor rev 7 (v6l)
BogoMIPS : 697.95
Features : swp half thumb fastmult vfp edsp java tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xb76
CPU revision : 7
Hardware : BCM2708
Revision : 000d
Serial : 00000000f6d9c7a5
Ce qui nous intéresse se trouve sur l’avant dernière ligne « Revision : 000d ». D’après le tableau ci-dessous, il s’agit d’un Model B Revision 2.0 512MB fabriqué par Egoman
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.
Aujourd’hui, un petit article pour vous présenter deux initiatives qui s’inscrivent dans la démarche Maker et DIY, et qui valent le détour : culturemaker.fr et ludins.fr.
CultureMaker.fr
culturemaker.fr est un blog tout jeune qui traite de tous les sujets autour du mouvement Maker, FabLabs, en passant par l’OpenSource et l’OpenHardware. Effectivement, derrière tous ces projets basés sur des Raspberry Pi, l’objectif est bien de créer de nouveaux systèmes en mode DIY. C’est exactement dans cette démarche que s’inscrit magdiblog.fr.
Le but de culturemaker.fr est de démocratiser le mouvement Maker en France. Et rien que pour ça, ils méritent un coup de pousse
Ludins.fr
Créée par la même équipe, ludins.fr est une plateforme d’échange de tutoriels autour du Do It Yourself technologique. L’objectif est de fournir aux utilisateurs des tutoriels très détaillés de manière à ce que n’importe qui puisse les suivre. Là encore, c’est la philosophie de magdiblog.fr, et c’est pourquoi je soutiens à 100% leur démarche bien que la plateforme soit encore en cours de construction.
La culture Maker et DIY
La culture Maker et le DIY (Do It yourself) sont deux mouvements qui ont le vent en poupe depuis quelques années mais qui peinent à se démocratiser en France, et je trouve ça dommage
Je me permet donc de faire un peu de propagande et vous incite à lire les articles Wikipédia sur la culture maker et le DIY pour vous inspirer de la philosophie et des valeurs portées par ces mouvements.
J’espère que la culture maker et le DIY vont se démocratiser en France, comme je l’expliquais dans une interview donnée à culturemaker.fr sur le sujet :
Selon-vous, comment va évoluer mouvement Maker en France ? Ce mouvement explose en Amérique, que lui manque-t-il pour être démocratisé en France ?
J’espère vraiment que le mouvement prendra de l’essor en France. Nous avons tout ce qu’il faut et nous avons besoin d’innovation, de nouvelles idées et de gens créatifs
Mais je ne peux m’empêcher d’être septique, car ce mouvement reste marginal et que rien en France ne soutiens ce genre d’initiative. Il y a également un problème de mentalité qu’il faut faire évoluer. Un Maker qui se présente à un entretien d’embauche et qui met en avant ses travaux, passera pour un « bricoleur amateur du dimanche », et ne sera pas pris au sérieux. Un autre exemple, mon projet de drone avion autonome. A peine l’article publié, les commentaires virulents fusent « C’est interdit », « On n’a pas le droit », « Ne fait pas ça, c’est dangereux »… Tout ceci est regrettable.
Aux USA, les mentalités sont différentes, tout le système éducatif et les entreprises poussent l’innovation et la créativité. Et cela se ressent sur les Makers. En France, il y en a très peu. Aux USA, beaucoup ont créé des starup autour de leurs projets et les industriels suivent. Regardez Adafruit par exemple. Ils fabriquent tous les jours de nouveaux composants. Je ne connais aucune entreprise française de ce type… Sur Lille les magasins d’électroniques ferment les uns après les autres…
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
Les différents modèles de Raspberry Pi sont vendus nus entre 35€ et 40€. A cela, il faut ajouter un certain nombre de composants (carte mémoire, alimentation et boîtier à minima) pour avoir un système fonctionnel.
Alors que certains accessoires tels que les boîtiers n’ont que peut d’impact sur la fiabilité de l’ensemble, une alimentation de mauvaise qualité ou une carte mémoire fragile peuvent être à l’origine de nombreux problèmes de stabilité ou de pannes.
Le but de cet article est de référencer les composants de qualité à privilégier et de relever les points importants à prendre en compte lors de l’achat d’un accessoire, afin de faire le tri dans l’offre pléthorique de l’écosystème Raspberry Pi.
Cela fait presque trois ans que je manipule des Raspberry Pi (une bonne vingtaine tous modèles confondus) et j’ai pu tester de nombreux composants et accessoires.
Force est de constater que tous ne se valent pas… Au cours de mes diverses expérimentations, j’ai grillé trois Raspberry Pi et une demi-douzaine de cartes mémoires…
Les observations et recommandations faites dans cet article sont basées sur mon expérience personnelle et n’engagent que moi.
J’encourage tous les lecteurs à enrichir cet article en partageant leurs expériences dans les commentaires. Je tâcherai de mettre à jour le contenu de l’article en suivant les tendances générales.
Le Raspberry Pi
Parmi tous les modèles disponibles actuellement, seuls deux sont réellement pertinents à mon sens :
Si vous travaillez sur un projet « fixe » avec une alimentation secteur ou si vous avez besoin de puissance, préférez le modèle 2 B, qui outrepasse tous les autres modèles en terme de puissance.
En revanche, si vous travaillez sur un système embarqué ou fonctionnant sur batterie, choisissez le modèle A+ qui est le modèle le plus compact et le plus économe en énergie.
L’alimentation secteur
Entrons dans le vif du sujet avec le composant le plus sensible. Rappelons ce qu’il en est : d’un côté, le Raspberry Pi, un mini-ordinateur bourré de micro-contrôleurs, nécessitant une tension d’alimentation très précise de 5V et un courant de 300mA à 1,5A environ ; de l’autre, des centaines de chargeurs de qualité très variable et initialement prévus pour recharger des téléphones portables. Ce qu’il faut savoir, c’est qu’en général, les téléphones sont équipés d’un circuit de charge dont le rôle est de « gérer » le courant pour charger la batterie. Si le courant n’est pas tout à fait propre (variations de tension), le circuit de charge peut gommer les défauts afin de protéger le téléphone et la batterie. De ce fait, les fabricants de chargeurs ne s’encombrent pas avec la qualité, privilégiant de faible coûts de production.
En réalité donc, la majeure partie des chargeurs que l’on peut trouver dans le commerce fournissent un courant de piètre qualité… Avec 5V affiché, on peut très bien se retrouver avec 4,2V fluctuants au gré des variations de tensions et des parasites qui perturbent le réseau électrique EDF. Au niveau puissance, même combat, un chargeur affichant 5W (soit 1A sur 5V), pourra en fait trouver sa limite à 600mA, ce qui fera freezer votre Pi s’il nécessite plus de courant… Ca n’a pas l’air affolant dit comme ça, mais pour un Raspberry Pi l’effet est exactement le même que si vous viviez avec un coeur dont le rythme varierait de 10 à 50 battements par minutes… Oui, une mauvaise alimentation peut être fatale pour votre Pi.
Après avoir testé plusieurs marques de chargeurs, je vous déconseille fortement les modèles proposés par les marques Energizer, Belkin et consorts…
Les chargeurs qui semblent se démarquer en terme de qualité sont ceux d’Apple (pour l’iPad) et ceux de la marque Aukru.
Pour résumer, choisir une bonne alimentation vous mettra à l’abri des risques d’incendie, d’une part, et augmentera la durée de vie de votre Pi et des composants qui y sont rattachés, d’autre part. Evitez autant que possible les marques inconnues ou douteuses et prévoyez large au niveau de la puissance (10W minimum, soit 2A sur 5V pour être tranquille, surtout pour le modèle Raspberry Pi 2 B).
Pour résumer, vous pouvez utiliser des batterie de secours pour téléphone portable ou des blocs coupleurs de piles AA ou AAA.
Niveau batterie de secours, j’ai pu tester les marques Romoss, Tecknet et Anker. Les modèles Anker semblent être globalement de meilleure qualité. Mais les trois batteries que je possède (une de chaque marque) fonctionnent parfaitement bien. Ne vous fiez cependant pas aux capacités annoncées qui sont très largement sur-estimées (prenez environ 60% de la capacité annoncée pour avoir une idée de la capacité réelle).
Pour ce qui est des piles, choisissez un coupleur standard et les piles de votre choix. Personnellement, depuis le dossier comparatif réalisé par le magazine Canard PC, je n’utilise que des piles Ikea et j’en suis très satisfait Un rapport qualité prix imbattable !
Sur un Raspberry Pi, la carte mémoire (SD ou micro-SD selon les modèles), fait office de disque dur. Sur l’ensemble de mes expérimentations, c’est l’élément qui s’est montré le plus fragile. J’ai bousillé une bonne demi-douzaine de carte SD, et je soupçonne les problèmes de qualité d’alimentation d’y être pour quelque chose…
J’ai eu l’occasion de tester la plupart des grandes marques disponibles sur le marché et que l’on trouve dans les grandes surfaces. Encore une fois, cela n’engage que moi, mais les cartes mémoires qui se sont révélées être les plus fiables sont celles de la marque SanDisk. A l’inverse, toutes mes cartes de marque Kingston ont terminé à la poubelle…
Au niveau capacité, 8Go me semble être un minimum. Sachez qu’entre la répartition des partitions et l’espace occupé par le système, une Raspbian de base dévore près de 3Go. Il vous restera donc moins de 1Go si vous partez sur une carte de 4Go.
Soyez également attentif à la « classe ». En effet, les cartes SD sont catégorisées en quatres classes : 2, 4, 6 et 10, qui correspond respectivement aux vitesses d’écriture 2Mo/s, 4Mo/s, 6Mo/s et 10Mo/s. Je vous recommande donc les cartes de classe 10 qui offrent les meilleures performances pour votre Pi.
Il existe des dizaines de modèles différents et même si le choix d’un boîtier n’a strictement aucun impact sur les performances du Pi, il convient de le choisir en fonction de l’utilisation que l’on souhaite en faire. Inutile de dépenser plus de 20€ dans un boîtier vendu avec des dissipateurs ou des ventilateurs… on n’en est pas non plus à faire du watercooling…
Si vous n’utilisez pas le port caméra ou le GPIO, vous pouvez prendre n’importe quel boîtier adapté à votre modèle de Pi. En revanche, si vous avez besoin d’accéder facilement au port GPIO, veillez à choisir un boîtier que vous pouvez ouvrir facilement ou qui dispose de fentes autorisant le passage de fils/câbles.
Si vous utilisez une carte d’extension comme la piFace ou autre, sachez qu’ils existe des boîtiers prévus à cet effet, mais ils sont rares…
J’aime beaucoup les boîtiers en acrylique. Vendus démontés sous forme de plaques d’acrylique pré-découpées, ils sont généralement moins chers et plus modulaires que les autres boîtiers.
Munis de fentes pour la nappe caméra, le port GPIO et la carte SD, vous pouvez également utiliser ce type de boîtier avec des cartes d’extension volumineuses. Il vous suffira de retirer la plaque du dessus.
Le dongle WiFi
Accessoire non obligatoire, le dongle WiFi est toutefois indispensable dans un certain nombre cas. Dans l’univers du Raspberry Pi, le dongle WiFI le plus connu est le Edimax EW-7811UN. Il fonctionne parfaitement bien avec tous les modèles de Pi.
Cependant, je trouve qu’il est relativement limité en terme de puissance et de portée. C’est pourquoi je préfère le modèle Netgear WNA1000M, souvent quelques Euros moins cher. Ce modèle vous permettra également de créer un point d’accès WiFi avec votre Raspberry Pi.
Ces « nano » dongles WiFi conviennent parfaitement à un usage domestique. Si vous avez besoin de plus de puissance ou de portée, vous pouvez utiliser le modèle Alfa Networks AWUS036H (j’en ai un pour un Raspberry Pi situé dans mon abris de jardin à environ 20m de la maison, et la liaison WiFi est impeccable. De plus, ce modèle autorise l’injection de paquets… je dis ça comme ça ).
Il ne s’agit pas d’un accessoire indispensable pour faire fonctionner un Raspberry Pi (contrairement à l’alimentation et la carte SD), mais il s’agit d’un composant souvent utilisé.
Bien sûr, vous pouvez utiliser une webcam USB mais le module Raspberry Pi Caméra conçu par la Fondation Raspberry Pi est vraiment d’une qualité remarquable.
Disponible en version standard et en version infrarouge aux alentours de 25€, le module Raspberry Pi Caméra est dotés d’un capteur photo de 2592 x 1944 pixels (soit 5 méga-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 et libère du même coup le port USB
La qualité des images et très satisfaisante, mais ce qui fait vraiment la différence, c’est la richesse des outils logiciels (raspistill et raspivid) disponibles nativement sur Raspbian.
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 :
En passant du CPU monocoeur ARM11 cadencé à 700 MHz, qui armait tous les modèles jusqu’alors, au CPU quadricoeur ARM Cortex-A7 cadencé à 900MHz, le dernier né des Raspberry Pi offre un gain de performances fulgurant qui rend totalement obsolète tous les autres modèles ; exception faite, bien entendu, du modèle A+ qui reste une référence pour les projets embarqués.
Hormis le CPU et la quantité de RAM, le modèle 2 est strictement identique au modèle B+. Même carte, même ports, même GPU, 4 ports USB, 1 port Ethernet. Il s’agit d’un B+ boosté. Toutes les applications, cartes d’extensions et boîtiers sont donc compatibles.
Performances
Le CPU monocoeur ARM11 à 700MHz et les 256/512 Mo de RAM étaient suffisants pour la plupart des petits projets de prototypage, des petits serveurs de stockage (NAS, FTP,…), et permettait même d’utiliser un Pi comme box multimédia avec le bien connu XBMC récemment rebaptisé KODI.
Toutefois, on se frottait relativement vite aux limites du petit CPU monocoeur, et les 256/512 Mo de RAM étaient vite saturés. Même pour héberger un simple WordPress, avec un Apache et une base de données MySQL, le Pi se montrait poussif et incapable d’assumer plusieurs tâches en parallèles de manière fluide.
Pour avoir manipulé la bête sur différents projets, je peux vous dire que c’est très frustrant.
Avec un CPU quadricoeur boosté et 1Go de RAM, le Raspberry Pi 2 se montre beaucoup, beaucoup plus réactif sur l’ensemble des applications ; jusqu’à 6 fois plus rapide comme annoncé par la fondation (et jusuqu’à 30 fois plus rapide dans certains cas).
Bien que depuis le premier modèle A le Pi était vendu comme un véritable ordinateur capable d’offrir une expérience bureautique convenable (avec bureau, navigateur web, etc…), il faut bien admettre que l’ensemble manquait franchement de réactivité et que l’usage d’un Pi comme ordinateur de bureau n’était pas réellement envisageable pour tous les jours…
Le modèle 2 tient quant à lui la promesse comme on peut le voir dans cette vidéo qui compare la navigation web entre les modèles B 1 et 2 :
La différence est frappante et fait plaisir à voir, d’autant que le prix est resté le même
Le Raspberry Pi modèle 2 peut donc être réellement envisagé pour un ordinateur de bureau, un petit serveur Web ou de stockage… La différence sur XBMC/KODI est également bluffante. Je faisais tourner une Raspbmc sur un modèle B depuis plusieurs mois, et la réactivité sur le modèle 2 est très agréable
Conclusion
Les deux derniers modèles de Raspberry Pi conçus par la fondation, le RPi 2 modèle B et le RPi A+ sont pour moi tout à fait complémentaires. Alors que le modèle A+, très compact et peu énergivore, est très adapté à des projets embarqués (drone, jukebox, borne, capteur, caméra…), le RPi 2 modèle B et sa configuration musclée convient parfaitement pour des projets nécessitants une plus grosse puissance de calcul (serveur, box multimedia, calculs…).
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.
Une question revient souvent dans les commentaires et les messages que je reçois : Comment faire pour se connecter sur un Raspberry Pi à distance si celui ci n’a pas d’ip fixe, comme c’est le cas avec les clés 3G par exemple ?
Je vous propose donc aujourd’hui un tout petit article pour vous montrer un moyen simple et efficace de garder la main sur votre Raspberry Pi connecté en 3G.
Si votre Raspberry Pi est connecté à internet via une clé 3G, vous aurez probablement constaté qu’il est souvent impossible de s’y connecter à distance et que son adresse IP n’est pas fixe. En effet, les infrastructures mises en place par les opérateurs de téléphonie mobile filtrent, la plus part du temps, les flux entrant, et l’adresse IP change à chaque connexion au réseau, et parfois même au cours d’une même session. Si vous avez installé un Raspberry Pi doté d’une clé 3G dans votre maison secondaire, ou que vous utilisez un Raspberry Pi en extérieur comme dans le projet PiTimeLapse, il faut contourner le problème pour pouvoir y accéder à distance.
Ce qu’il faut retenir, c’est que SSH (nativement présent sur une Raspbian et sur toute distribution Linux qui se respecte), permet de créer un « tunnel » ou un « lien » entre deux machines. Une machine A se connecte sur une machine B, et les machines A et B peuvent échanger des informations.
Si vous utilisez un Pi, vous vous y êtes probablement déjà connecté en utilisant SSH en utilisant la commande suivante :
ssh pi@adresse_ip_de_votre_pi
SSH connect back
Une fonctionnalité intéressante de SSH est d’autoriser les « connections retours ». C’est à dire que si A se connecte sur B, alors B pourra revenir sur A. Et c’est là que se trouve la solution à notre problème Si je ne peux pas directement me connecter à mon Pi, je n’ai qu’à dire à mon Pi de se connecter à une machine que je contrôle, pour que je puisse ensuite remonter jusqu’à lui
Ceci se fait de manière très simple. Sur le Pi connecté en 3G lancez la commande suivante :
ssh -N -R 10022:127.0.0.1:22 root@ip_serveur
-N : ne lance pas de commande sur le serveur distant
-R : « redirige un port » sur depuis le serveur disant
10022 : un numéro port (de préférence supérieur à 1024), qu’on utilisera pour se connecter en retour
127.0.0.1 : pour indiquer qu’on redirige le port sur la boucle locale du Pi
22 : numéro du port que l’on souhaite atteindre. Ici, c’est le port utilisé par SSH. Vous pouvez le changer pour celui de VNC, ou de FTP par exemple.
A ce stade, votre Pi est connecté à votre serveur. Depuis votre serveur, vous pouvez vous connecter au Pi en retour en utilisant le port choisi (ici 10022). Si vous souhaitez à nouveau utiliser SSH pour vous connecter en retour sur votre Pi, il vous suffit de lancer la commande suivante depuis votre serveur :
ssh -p 10022 root@127.0.0.1
Ainsi, vous n’avez plus besoin de connaître l’adresse IP de votre Pi connecté en 3G, et vous passez à travers tous les filtres mis en place par les opérateurs de téléphonie mobile
Si vous voulez vous assurer que le tunnel entre le Pi et votre serveur persiste même après une déconnexion/reconnexion au réseau (ce qui arrive très souvent en 3G), vous pouvez utiliser autossh. Plus d’information sur autossh ici : http://linux.die.net/man/1/autossh
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
Cet article est réservé aux modules créés par la communauté.
Vous pouvez m’envoyer vos modules pour qu’ils soient disponibles sur cette page et téléchargeable par tous les lecteurs. Il vous suffit de me contacter via le formulaire de contact puis de m’envoyer par mail votre module sous forme d’archive zip portant le nom de votre module (ex : xplanet.zip) et contenant au moins les 4 fichiers suivants (ce qui facilitera leur intégration) :
ajax.php
inc.php
javascript.js
style.css
La présence d’un fichier readme.txt est vivement recommandée
Liste des modules créés par la communauté
1 – Module – Cadre photo(proposé par Sébastien)
Description :Un module permettant de faire défiler des photos à l’instar des cadres photos numérique bien connus
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.
Connexion
Il vous suffit d’implémenter ce morceau de code dans le celui du Mini Pi Dash Screen et le tour est joué !
J’ai envie de l’ambrasser 
Je vous souhaite à toutes et à tous une excellente nouvelle année 2016, pleine de projets 
Je vous souhaite à toutes et à tous d’excellentes fêtes de fin d’année 
La réponse : faire un deuxième bateau, plus simple, plus petit, qui pourra accompagner le premier.
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.
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 devrez également avoir installé et configuré le module z-wave Razberry ou le module USB RFXtrx433 ainsi que Domoticz comme expliqué ici : 
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 ».
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 
culturemaker.fr est un blog tout jeune qui traite de tous les sujets autour du mouvement Maker, FabLabs, en passant par l’OpenSource et l’OpenHardware. Effectivement, derrière tous ces projets basés sur des Raspberry Pi, l’objectif est bien de créer de nouveaux systèmes en mode DIY. C’est exactement dans cette démarche que s’inscrit magdiblog.fr.
Le but de cet article est de référencer les composants de qualité à privilégier et de relever les points importants à prendre en compte lors de l’achat d’un accessoire, afin de faire le tri dans l’offre pléthorique de l’écosystème Raspberry Pi.
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 :
Le Raspberry Pi 2 étant vendu au même prix que le B+, ne nous en privons pas !
Le CPU monocoeur ARM11 à 700MHz et les 256/512 Mo de RAM étaient suffisants pour la plupart des petits projets de prototypage, des petits serveurs de stockage (NAS, FTP,…), et permettait même d’utiliser un Pi comme box multimédia avec le bien connu XBMC récemment rebaptisé KODI.
