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

Voici l’édito : http://www.canardpc.com/cpc-hardware-hs-n7-special-electronique-disponible.html

Le dernier article de ce numéro est consacré à la téléinfo EDF avec une mention spéciale à l’article de MagdiBlog : Téléinfo EDF – Suivi conso de votre compteur électrique

Etant moi même un grand fan de CanardPC depuis de nombreuses années, c’est pour moi une véritable consécration

 

 

L’article MagdiBlog dans le CanardPC Hardware Hors Série n°7 spécial électronique est apparu en premier sur MagdiBlog.

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

L’article Nouveau Raspberry Pi C bientôt disponible ! est apparu en premier sur MagdiBlog.

J’ai à peine eu le temps de vous vanter les mérites du modèle A+ pour les projets embarqués que la fondation sort le Raspberry Pi 2 modèle B.

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).

Voici un article intéressant sur les performances de ce nouveau modèle : http://www.silicon.fr/de-premiers-benchmarks-independants-pour-le-raspberry-pi-2-107756.html

Les utilisations possibles

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…).

L’article Raspberry Pi 2 : La puissance qui manquait est apparu en premier sur MagdiBlog.

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.

La version NoIR permet de voir les infra-rouge, ce qui autorisera une vision nocturne si on le couple à un projecteur infra-rouge comme expliqué à fin de cet article : Système de vidéo-surveillance abordable avec des Raspberry Pi

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 :

• Raspberry Pi A+
• Module Camera ou la version NoIR
• Un dongle WiFi Netgear WNA1000M
• Une carte micro-SD SanDisk 8Go
• Une batterie Romoss 5200mAh

Le Raspberry Pi A+ est vraiment idéal pour ce genre projet. Découvrez pourquoi en lisant cet article : Raspberry Pi A+ : Le meilleur de tous

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

nc -l -p 5001 | /usr/bin/mplayer -fps 10 -cache 1024 -

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 :

raspivid -t 0 -w 1280 -h 720 -o - | nc adresse_ip_du_pc_client 5001

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 :

nc -l -p 5001 | /usr/bin/mplayer -fps 10 -cache 1024 -demuxer h264es -dumpstream -dumpfile ./Bureau/ma_video.h264 -

Méthode 2 : streaming VLC

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 :

raspivid -t 0 -n --width 1280 --height 720 -o - | cvlc stream:///dev/stdin --sout '#standard{access=http,mux=ts,dst=:8090}' :demux=h264

Coté PC client, il suffit de lire le flux vidéo avec VLC grâce à la commande :

cvlc http://adresse_ip_du_pi:8090

Pour enregistrer le flux vidéo dans un fichier, utilisez la commande suivante :

cvlc http://adresse_ip_du_pi:8090 --sout file/ts:./Bureau/ma_video.h264

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 :

raspivid -t 0 -w 960 -h 540 -o - | nc adresse_ip_du_pi_visionnage 5001

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.

Voici le lien vers la page SourceForge de mjpg-streamer : http://sourceforge.net/projects/mjpg-streamer/

Dans un premier temps, installez les dépendances de mjpg-streamer ainsi que subversion :

apt-get install subversion libv4l-dev libjpeg8-dev imagemagick

mjpg-streamer aura besoin d’un fichier videodev.sh pour fonctionner correctement :

ln -s /usr/include/linux/videodev2.h /usr/include/linux/videodev.h

Téléchargez ensuite la dernière version de mjpg-streamer grâce à subversion, puis installez le en utilisant les commandes suivantes :

svn co https://svn.code.sf.net/p/mjpg-streamer/code/
cd code/mjpg-streamer
make USE_LIBV4L2=true clean all
make DESTDIR=/usr install

Une fois installé, créez un répertoire temporaire et lancez raspistill en mode timelapse pour capturer 2 images par secondes :

mkdir /tmp/stream
raspistill --nopreview -w 640 -h 480 -q 5 -o /tmp/stream/pic.jpg -tl 500 -t 9999999

Enfin, lancez mjpg-streamer grâce à cette commande :

LD_LIBRARY_PATH=/usr/local/lib mjpg_streamer -i "input_file.so -f /tmp/stream -n pic.jpg" -o "output_http.so -w ./www"

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.

Je vous invite à lire cet article pour en savoir plus sur cette méthode « artisanale » :  Système de vidéo-surveillance abordable avec des Raspberry Pi

Conclusion

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.

Article intéressant sur le sujet :

• http://blog.nicolargo.com/2013/05/streaming-depuis-la-raspberry-camera.html

L’article Raspberry Pi Camera – 5 façons de faire du streaming est apparu en premier sur MagdiBlog.

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.

L’article Raspberry Pi A+ : Le meilleur de tous est apparu en premier sur MagdiBlog.

Dans cet article, nous allons voir comment mesurer la température ambiante avec deux types de sondes thermomètres très différentes : la sonde numérique DS18B20 et la sonde analogique TMP36. Dans les deux cas, il s’agit d’un minuscule composant à trois pattes, dont la résistance des composants internes varie en fonction de la température.

Il faut savoir que le GPIO du Raspberry Pi ne dispose pas d’entrées analogiques, il est par conséquent impossible de mesurer la valeur d’une résistance ou d’un courant directement.

La sonde TMP36 étant un composant analogique, nous allons devoir utiliser un convertisseur analogique/numérique ou ADC (Analog to Digital Convert), comme le MCP3008.

La sonde  DS18B20 est, quant à elle, une sonde numérique qui utilise un bus/protocole particulier qui permet communiquer l’information à travers un seul câble (par extension, une seule broche du port GPIO du Pi) ; il s’agit du bus 1-Wire.

Matériel utilisé dans cet article

Pour réaliser ces deux montages, en plus des sondes TMP36 et DS18D20, vous aurez besoin d’une breadboard, de wire jumpers et d’une résitance. Vous pouvez trouver ces composants directement ici :

Sonde analogique TMP36 et ADC MCP3008

TMP36	MCP3008

Alimentée entre 2,7V et 5,5V (parfait pour le Pi qui peut fournir une alimentation de 3V ou 5V), la sonde TMP36 permet de mesurer des températures de -50°C à +125°C avec une précision annoncée entre 0,5°C et 1°C en moyenne. Fonctionnant dans la même plage de tension (2,7V à 5,5V), le convertisseur analogique/numérique MCP3008 dispose de huit entrées, ce qui permet de lire les informations de huit capteurs (de température ou autre). Le MCP3008 dispose d’une interface SPI, nativement supportée par le Pi En outre, il offre de résolution de 10 bits, ce qui va lui permettre de distinguer 2^10 soit 1024 valeurs. Il est important de noter que le MCP3008 permet un échantillonnage beaucoup plus fin (1024 valeurs) que ce que permet de mesurer le TMP36, ce dernier ne sachant distinguer que 50+125/0,5 soit 350 températures différentes (au mieux).

Le schéma ci-dessous montre comment brancher le MCP3008 sur le GPIO du Pi, et comment relier le TMP36 au MCP3008 :

En dehors des fils d’alimentation (en noir et en rouge), le bus SPI du MCP3008 occupe quatre broches sur le GPIO du Pi. La broche centrale (tension de sortie) du TMP36 est directement reliée à une des entrées du MCP3008.

Après les branchements, passons à la partie logicielle

Seul le paquet python-dev est strictement nécessaire pour utiliser l’interface SPI du MCP3008 :

apt-get install python-dev

Les dernières versions de Raspbian ne nécessitent pas de manipulations particulières pour utiliser le bus SPI du GPIO. Si toutefois vous rencontrez des problèmes, il faudra mettre à jour la lib Python rpi.gpio :

sudo easy_install -U distribute
sudo apt-get install python-pip
sudo pip install rpi.gpio

Intéressons nous maintenant au fonctionnement du MCP3008 pour comprendre comment extraire la température mesurée par le TMP36.

Le principe est relativement simple : le MCP3008 renvoie une valeur entre 0V et la tension de « référence«  (ici 3,3V ou 3300mV car nous avons connecté la broche Vréf du MCP3008 à la broche 3,3V du Pi). Cette valeur (en mV) est codée sur 10 bits (soit 2^10=1024 valeurs possibles) puis envoyée sur le bus SPI. Nous obtiendrons donc un nombre entier entre 0 et 1023. Pour obtenir la valeur en mV, il nous suffit d’appliquer une « règle de 3 » :

mV = valeur * 3300 / 1024

La tension renvoyée par le TMP36  se situe entre 0V pour -50°C et 1,75V pour 125°C, ce qui donne 1,75/(50+125)=0,01V soit 10mV par degré. Pour convertir les mV en degrés Celsius, nous devons donc réaliser le calcul suivant :

t °C = (mV / 10) - 50

(10mV par degré, puis on retire 50 car on part de -50°C à 0V)

Ci-dessous, un petit script Python, temperature_MCP3008_TMP36.py qui réalise toutes ces opérations et affiche la température en °C :

#!/usr/bin/env python

import time
import RPi.GPIO as GPIO

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)

# initialise les ports du GPIO
GPIO.setup(24, GPIO.OUT)
GPIO.setup(23, GPIO.IN)
GPIO.setup(18, GPIO.OUT)
GPIO.setup(25, GPIO.OUT)

# lit les donnees SPI du MCP3008 et renvoie un entier entre 0 et 1023
def readspi(mcp3008_input):
  GPIO.output(25, True)
  GPIO.output(18, False)
  GPIO.output(25, False)
  commandout = mcp3008_input
  commandout |= 0x18
  commandout <<= 3
  for i in range(5):
    if (commandout & 0x80):
      GPIO.output(24, True)
    else:   
      GPIO.output(24, False)
    commandout <<= 1
    GPIO.output(18, True)
    GPIO.output(18, False)
  bitout = 0
  for i in range(12):
    GPIO.output(18, True)
    GPIO.output(18, False)
    bitout <<= 1
    if (GPIO.input(23)):
      bitout |= 0x1
  GPIO.output(25, True)
  bitout /= 2
  return bitout

# boucle principale qui realise les calculs et affiche le resultat toutes les 5 secondes
while True:
  try:
    bitout = readspi(0) # lit les donnees de l'entree 0 du MCP3008
    mV = bitout * ( 3300.0 / 1024.0) # convertit la valeur en mV
    tC = (mV/10.0) - 50.0 # convertit les mV en degre Celsius
    tC = "%.1f" % tC # ne garde que une decimale
    print(tC)
    time.sleep(5)
  except KeyboardInterrupt:
    quit()

Et voilà Il ne vous reste plus qu’à envoyer cette température à votre dashscreen pour afficher la température ambiante de votre salon

Sonde numérique DS18B20 et bus 1-Wire

DS18B20

Alimentée en 3V ou 5V la sonde numérique DS18B20 offre une précision de 0,5°C, et permet de mesurer des températures entre -55°C et +125°C. Cette sonde utilise un bus 1-Wire qui permet de se passer d’un convertisseur analogique/numérique, et occupe ainsi une seule broche du port GPIO du Pi (en dehors des deux broches d’alimentation). Pour assurer le bon fonctionnement de cette sonde, il convient d’utiliser une résistance dite « pullup » pour appliquer une tension de « référence » à la borne centrale du composant. Dans notre cas, et avec un Pi, il convient d’utiliser une résistance de 4,7k ohm.

Le schéma ci-dessous montre comment brancher la sonde DS18B20 et la résistance sur le GPIO du Pi :

Pour faciliter le montage, vous pouvez souder la sonde et la résistance sur un petit morceau de plaque epoxy :

Passons à la partie logicielle qui est ici très simple. En effet, il suffit de charger les modules 1-wire nécessaires pour voir apparaitre un nouveau périphérique dans le répertoire /sys/bus/w1/devices :

modprobe w1-gpio
modprobe w1-therm

ls -l /sys/bus/w1/devices/
total 0
lrwxrwxrwx 1 root root 0 Dec  3 21:02 28-000005305b19 -> ../../../devices/w1_bus_master1/28-000005305b19
lrwxrwxrwx 1 root root 0 Dec  3 20:59 w1_bus_master1 -> ../../../devices/w1_bus_master1

Ici, ma sonde est détectée avec le numéro 28-000005305b19. Ce numéro est normalement unique et « gravé » en usine directement dans le composant. Si vous utilisez plusieurs DS18B20, vous devriez avoir plusieurs périphériques avec des numéros différents

Si vous lisez le contenu de ce nouveau périphérique, vous devriez obtenir quelque chose de ce type :

cat /sys/bus/w1/devices/w1_bus_master1/28-000005305b19/w1_slave 
7a 01 4b 46 7f ff 06 10 0b : crc=0b YES
7a 01 4b 46 7f ff 06 10 0b t=23625

La température est directement affichée en degré Celsius t=23625 Ou presque, car il faut tout de même diviser cette valeur par 1000.

Voici donc un petit script temperature_DS18B20.py dont le rôle est de lire le contenu de ce fichier et d’en extraire la température

#!/usr/bin/python

import os, glob, time, datetime

os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')

device_file='/sys/bus/w1/devices/28-000005305b19/w1_slave'

# lit le contenu du peripherique et extrait la temperature puis la divise par 1000
def read_temp():
  f = open(device_file, 'r')
  lines = f.readlines()
  f.close()
  temp_string = lines[1].strip()[-5:]
  temp_c = float(temp_string)/1000.0
  return temp_c

# boucle principale qui affiche la température toutes les 5 secondes
while True:
  try:
    tC = read_temp()
    print(tC)
    time.sleep(5)
  except KeyboardInterrupt:
    quit()

Et voilà, très simple, très économique, et relativement précis

TMP36 vs DS18B20

Par curiosité j’ai réalisé un script qui compare la température mesurée par le TMP36 et le DS18B20 :

TMP36 : 22.8 - DS18B20 : 23.2
TMP36 : 22.5 - DS18B20 : 23.2
TMP36 : 22.5 - DS18B20 : 23.2
TMP36 : 22.5 - DS18B20 : 23.2
TMP36 : 22.5 - DS18B20 : 23.2
TMP36 : 22.8 - DS18B20 : 23.3
TMP36 : 27.3 - DS18B20 : 28.0
TMP36 : 29.3 - DS18B20 : 29.4
TMP36 : 28.3 - DS18B20 : 28.3
TMP36 : 26.7 - DS18B20 : 27.1
TMP36 : 25.7 - DS18B20 : 26.4
TMP36 : 24.8 - DS18B20 : 25.9
TMP36 : 24.4 - DS18B20 : 25.6
TMP36 : 24.1 - DS18B20 : 25.4
TMP36 : 23.8 - DS18B20 : 25.2
TMP36 : 23.8 - DS18B20 : 25.1
TMP36 : 23.8 - DS18B20 : 25.0

Pour faire augmenter la température, j’ai posé un doigt sur chaque sonde. On constate que les deux sondes mesures des températures très proches. Le DS18B20 mesure cependant une température d’environ 0,5°C plus chaude que le TMP36.

Dans tous les cas, on ne peut qu’espérer une précision à 0,5°C. J’ai pu constater que ma station météo ainsi qu’un autre thermomètre de mon appartement affichent des températures similaires, avec des écarts jusqu’à 1°C.

L’article GPIO – Capteurs de température est apparu en premier sur MagdiBlog.