167 réponses à ce sujet

[sky99]

La liste des tutoriels publiés dans le topic est accessible en post #2

Bonjour à tous!

Je suis étudiant en dernière année de thèse, en informatique (IA), et depuis peu, je me suis mis à des projets hardware en utilisant des Raspberry Pi.
L'informatique est une science passionante, mais on manque parfois de retours dans "le monde réel". Avec des étudiants de mon université, nous avons donc démarré une sorte de petit club de robotique, et j'ai du pour cela acquerir des compétences diverses en électronique, mécanique, automatismes, etc. Je ne prétends pas être un roboticien accompli, mais j'ai compris quelques petites choses, et parfois cela m'a pris du temps. C'est pour cela que j'ai décidé de faire des tutoriels de ce que je sais, mais je souhaiterais également partager cette passion nouvelle avec d'autres usagers. Ce que je vous propose donc ici, c'est que les INpacticiens qui s'intéressent à ces sujets se regroupent pour échanger, s'entraider et creer des ressources utiles à tous.

• Si vous êtes intéréssé(e) mais completement novice, je me propose d'aider quiconque le souhaitera à démarrer, et à réaliser des projets simples à moyennement complexes.
• Si vous êtes un expert, venez donc donner vos conseils, ou même simplement signifier votre présence, de sorte que si d'autres spécialistes débarquent, on puisse faire des discussions de haut vol (qui finiront par intérésser les novices quand ils auront progréssé!)

Pour l'instant, ce que je vous propose, c'est d'explorer divers domaines :

1- La Robotique
Les robots, c'est cool. Pas besoin de discuter la dessus. Faire un robot pour en fabriquer un, c'est déja une raison valable. Mais on peut en plus aller plus loin, en essayant de faire des robots utiles, ou simplement adaptés à vos désirs. Le point important, c'est qu'on peut faire un robot pour 60 à 100$ (donc bien moins, en euros!), et cela sans aucune compétence en électronique. Il suffit de s'acheter deux trois composants, et HOP, on a ce qu'il faut pour fabriquer un robot. Je peux vous conseiller sur du matériel nécéssaire à la fabrication de robots simples (robots à roues, je n'ai pas encore commencé à faire des robots marcheurs, même si en principe le concept ne m'inquiete pas plus que ça, maintenant que j'en sais un peu plus), capables de se déplacer dans un environnement quelconque en évitant les obstacles. En pratique, on peut faire :

• Faire un robot de base à conduite différentielle;
• Des robots a évitement d'obstacles par capteur infrarouge, ou encore ultrason. On peut aussi avoir des capteurs de contact, et ainsi faire un robot "tactile".
• Utiliser une webcam pour détecter les obstacles, en analysant l'image avec OPENCV
• S'amuser à cartographier un environnement en utilisant les capteurs d'un robot se déplaçant dans une piece.
• Faire des robots de "combat", genre miniSumo
• Des robots suiveurs de ligne
• Prendre un jouet télécommandé, et le transformer en robot contrôlé par le PI (ou un Arduino);
• Faire un robot qu'on commande depuis un PC/téléphone/tablette ou autre, en regardant le flux de la webcam de celui ci;
• Bien d'autres choses!

2- La Domotique
Je ne sais pas pour vous, mais moi, j'aimerais bien avoir une maison intelligente, contrôlée par la voix, avec plein de fonctions automatiques qui font un peu science fiction. Eh bien pourquoi ne pas essayer? La domotique, c'est le fait de contrôler de façon informatisée des organes de la maison. Pour faire simple, voici des exemples de choses qu'on peut facilement faire :

• Allumer et eteindre des lumières d'une piece depuis un ordinateur. C'est très simple, il suffit d'un relais.
• Capter les signaux infrarouges des télécomandes de vos appareils, et ensuite parvenir à les ré-émettre. Cela permettrait par exemple d'allumer la télé et le sat depuis votre PC, ou d'allumer la clim en partant du boulot pour qu'il fasse frais en rentrant, et ce depuis une interface web.
• Commander des dispositifs selon la valeurs de capteurs. Une lampe qui s'allume automatiquement s'il fait sombre, mais qui peut ne pas le faire au dela d'une certaine heure par exemple. Nous pouvons refaire des choses vendues très cher dans le commerce, pour une fraction infime du prix, et tout en ayant une très forte capacité d'optimisation, de programmation, etc...
• La vidéo-surveillance : une caméra IP, ça coute très cher. La résolution est souvent limitée à 640*480. Avec un raspberry Pi, deux servomoteurs, et quelques éléments divers, il est possible de fabriquer soi même une caméra IP simple, ou même MOTORISÉE, et dont la définition sera celle de notre choix. On peut s'en sortir pour moins de 100€ avec une capacité full HD en vidéo et bien plus en photo. Encore une fois, il est possible de rajouter des capteurs suplémentaires, par exemple un capteur de mouvement, un micro, faire de la reconnaissance faciale avec openCV, du suivi automatique des individus, faire des statistiques (combien de personnes sont passées, combien de fois le chat est il passé, etc), ou même intégrer un répondeur vidéo : Bob passe, je ne suis pas la. Bob dit à la caméra qu'il veut me laisser un méssage, et je le trouve en rentrant, ou alors il me l'envoie directement. Il peut aussi pourquoi pas lancer une conversation vidéo avec moi sur mon smartphone... L'imagination est la seule limite (ou presque ^^)
• Allumer/eteindre la clim (ou le chauffage, en France continentale) selon la température, mais ne pas le faire s'il n'y a personne
• Se faire un super lecteur multimédia, réseau, wifi, lisant la Full HD avec RaspBMC et un raspberry, et encore une fois, on peut ajouter le code qu'on veut dedans pour faire des choses en plus!
• Contrôler de l'éclairage d'ambiance en faisant varier les couleurs avec des LED RGB;
• Et encore tout un tas de choses!

3 - De la "Citizen Science"
On peut vouloir faire des choses simplement parcequ'on est curieux. Moi j'aime bien mesurer des trucs, parceque c'est mon esprit scientifique, je suis curieux. Je vous propose donc d'essayer de faire des projets divers en utilisant divers capteurs, par exemple :

• Une station météo. On peut fabriquer un anémomètre (non calibré, mais on a une indication tout de même) avec deux canettes de soda, une tige métallique, un peu de bois/plastique, un capteur hall (qui détecte un champ magnétique), et un aimant. Il est très facile de lire des capteurs de température, tels que le TMP36, ou encore un capteur numérique tel que le DS18B20. On peut mesurer l'ensoleillement avec une photo-résistance (LDR, Light Dependant Resistor). Un pluviomètre n'est pas très complexe à fabriquer non plus, et il existe des capteurs de pression atmospherique, et d'hygiométrie très peu couteux;
• Mesurer la qualité de l'air. J'ai un concept pour cela, impliquant un emetteur et un récepteur infrarouge, pour mesurer la diffraction de la lumière causée par les particules présentes dans l'air;
• Faire un système pour photographier automatiquement les animaux dans leur milieu, en visant dans la bonne direction ou alors commander à distance la prise de photos/vidéos par wifi, avec un système alimenté par batteries;
• Faire des vidéos en time-lapse du ciel nocturne, ou de n'importe quoi d'autre, d'ailleurs;
• Fabriquer des paneaux solaires qui s'orientent face au soleil pour un rendement maximum (et la question intéréssante est de savoir à partir de quelle puissance de paneau solaire, le systeme peut alimenter le PI la journée en rechargeant une batterie pour tenir la nuit! Mais dans tous les cas, c'est possible avec un Arduino, ou même des puces type atmega ATTINY qui ne consomment quasiment rien.);
• Transmettre des données par LASER! Pourquoi? parceque les lasers, ça roxxe! Et pourquoi pas des lasers sur des robots? encore plus roxxor :);
• Capter des transmissions radio, emettre dans le respect de la réglementation;
• Fabriquer des antennes wifi directionnelles (et pourquoi pas motorisées) et essayer de voir a quelle distance on peut capter/émettre;
• Mesurer des paramètres divers sur une automobile;
• Et tellement d'autres choses!!!

4- S'amuser!
Pourquoi ne pas faire simplement des choses parceque c'est fun?
Faire une tourelle "lance bidules" automatisée, qui vise les humains, faire un robot qui poursuit le chat, fabriquer un systeme de monitoring du PC avec un écran LCD parceque "ça en jette".

Une idée fun : fabriquer le détecteur de mouvement de Aliens. Un pi, une petite boite, un petit LCD graphique, un HP, et on fait les "puiiiipiip" du détecteur de Alien... Et pourquoi pas utiliser un détecteur PIR, ou des détecteurs ultrasons pour réellement détecter des objets mouvants?

Fabriquer un HAL 3000 (une mini version du HAL9000) avec un HP, de la synthèse et de la reconnaissance vocale, et pourquoi pas une caméra dans "l'oeil" de HAL? En tous cas, l'un de mes PI aura un tel boitier, juste pour le fun

Bref, on peut faire tout un tas de choses. Ces idées, ce sont des idées que j'ai eues, mais je suis sur que vous en avez plein d'autres. Pour beaucoup de ces projets, il faut apprendre à faire des choses diverses qui serviront pour beaucoup d'autres. Par exemple, pour faire un robot, il faudra apprendre à contrôler des moteurs électriques ou des servomoteurs, et lire des capteurs. Les capteurs peuvent servir à une station météo, à la domotique, ou à monitorer le PC par ex. Les servomoteurs peuvent servir à commander une caméra motorisée. Les moteurs peuvent également actionner toutes sortes de mécanismes.

L'objectif est donc qu'on échange sur nos projets, et qu'on se partage des ressources. Mon plan est de faire un tutoriel à chaque fois que j'apprends un truc nouveau significatif. Et sur des sujets simples, je peux faire des tutoriels sur les sujets sur lesquels vous avez des questions.

J'espère donc vous voir nombreux!

Au passage, je tiens à signaler qu'un tutoriel, c'est parfois très long à faire et qu'après un certain temps de frappe, on en a marre. Donc ne soyez pas surpris si vous voyez un post qui s'arrête brutalement, c'est que je fais une pause, si vous sentez qu'il manque la suite ne vous en inquiétez pas, ça viendra par la suite. Par contre si le post suivant est arrivé sans ajouter les informations qui vous intéressent, c'est que je n'y ai pas pensé, que j'ai oublié, ou que je n'ai pas eu l'impression que c'était important. Donc posez des questions, si je peux, j'y répondrai, et j'étofferai la section relative. Merci de votre patience :)

Modifié par sky99, 14/02/2013 - 01:57.

[sky99]

Tutoriels postés
Pour l'instant, nous avons 25 tutos détaillés, dont 10 généraux et 15 sur l'utilisation de composants électroniques!
Tutoriels généraux

• Qu'est-ce que le Raspberry pi, exactement? Une description du Raspberry Pi, son architecture, et surtout son intérêt. Des liens vers les revendeurs officiels, des infos sur les ports GPIO qui seront si utiles en robotique, sur le protocole CEC si pratique pour un média player, et bien d'autres choses!
• Les composants de base qui nous seront utiles : Dans ce post, je décris quelques composants de base indispensables ou très utiles pour expérimenter, tels que les plaques de prototypages, les jumper wire, quelques composants électroniques, et quelques puces...
• Les capteurs analogiques et numériques : ces capteurs nous permettront de mesurer des choses, et seront les "yeux" et "oreilles" de nos robots, stations météo, etc...
• Explications sur les moteurs électriques (DC) et les servomoteurs;
• Quelques "packs" de composants intéressants à acheter avec votre Raspberry;
• Installation de Raspbian, le portage pour Raspberry de Debian sur la carte SD du Raspberry;
• Configuration de Raspbian pour faire fonctionner le protocole I²C, dans le post sur le MCP23017 (sautez la partie qui ne vous intéresse pas).
• Capturer des images et/ou un flux vidéo provenant d'une webcam, et les diffuser via un serveur web sur le PI. A noter qu'on peut aussi récupérer le flux vidéo depuis VLC pour le visionner, ou même l'enregistrer;
• Créer un démon unix pour lancer un script qui continue à s’exécuter, avec possibilité d'un lancement automatique au démarrage.

Tutoriels électroniques pratiques

• Commander une LED depuis un GPIO du Raspberry Pi, et aussi dans le même post comment utiliser WiringPi pour commander les GPIO en C, compiler et exécuter;
• Lire la valeur d'un bouton poussoir ou d'un interrupteur depuis les GPIO du Raspberry Pi, et du code pour commander une LED depuis le bouton poussoir.
• Connecter un convertisseur ADC (analogique vers numérique) MCP3008 au Raspberry Pi pour lire la valeurs de capteurs analogiques, avec un exemple lisant la valeur d'un potentiomètre;
• Lire la valeur d'une photo-résistance via le MCP3008 depuis le Raspberry;
• Déterminer la distance à un objet, avec un capteur de distance infrarouge Sharp, ou un capteur de distance ultrasonique Maxbotix (en utilisant un MCP3008 dans les deux cas);
• Mesurer des températures à l'aide d'une sonde analogique TMP36 et d'un MCP3008;
• Commander un ou deux moteurs depuis les GPIO à l'aide d'une puce L293D;
• Ajouter des GPIO (jusqu'à 128!) au Raspberry Pi en le protégeant des erreurs, avec un MCP23017 (+16GPIO) ou un MCP23008 ( +8 ) . Il y a auss des explications sur le protocole I2C et comment configurer Raspbian pour le faire fonctionner.
• Contrôler des DEL RGB à anode commune ou à cathode commune pour faire les couleurs de votre choix avec une DEL.
• Alimenter un Raspberry Pi de façon autonome, sans secteur, avec des piles/batteries AA et un convertisseur de tension efficace. Des tests d'autonomie sont également présentés.
• Commander des servomoteurs en utilisant la PWM logicielle de wiringPi, sans composants supplémentaires. Pour l'instant le résultat n'est pas ultra précis, mais ça fonctionne, et facilement, sans rajouter tout un tas de composants dédiés!
• Lire un capteur de température DS18B20 avec votre Raspberry - Par Yaug. Ce capteur est numérique, et ne demande donc pas de ADC, juste du fil et une résistance, pour obtenir les températures quand vous voudrez!
• Connecter et utiliser un écran LCD entre 2x16 et 4x20 caractères, avec ou sans rétro-éclairage RGB.
• Lire une sonde avec un Arduino et communiquer sans fil (433Mhz) avec le Raspberry Pi - Par Yaug. Au passage, on y parle aussi de reconnaissance vocale, et de puces Arduino "standalone", qui sont bien moins chères...
• Lecture d'une sonde DHT22 avec un arduino et avec un Raspberry Pi- Par Yaug.

Sondes et capteurs

• Lire la valeur d'un bouton poussoir ou d'un interrupteur depuis les GPIO du Raspberry Pi;
• Connecter un convertisseur ADC (analogique vers numérique) MCP3008 au Raspberry Pi pour lire la valeurs de capteurs analogiques;
• Lire la valeur d'une photo-résistance via le MCP3008;
• Déterminer la distance à un objet, avec un capteur de distance infrarouge Sharp, ou un capteur de distance ultrasonique Maxbotix;
• Lire un capteur de température DS18B20 avec votre Raspberry;
• Lire une sonde avec un Arduino et communiquer sans fil (433Mhz) avec le Raspberry Pi.
• Lecture d'une sonde DHT22 avec un arduino et avec un Raspberry Pi- Par Yaug.

Robotique

• Présentation de R. Cerda, un robot Raspberry Pi à conduite différentielle. C'est un robot très simple, économique, et utilisant un Raspberry Pi et 4 puces. Des explications sont/seront présentes sur le fonctionnement et la fabrication de ce robot.
• Choix du matériel et explications sur ces choix pour la construction d'un robot du type de R.Cerda;
• Principe et schémas de la partie éléctronique d'un Robot Raspberry Pi simple, de type R.Cerda;
• Les instructions sur la construction physique, l'assemblage du robot, la construction d'un châssis simple, etc.
• Programmation d'un robot Raspberry Pi de type R.Cerda;
• Commander un ou deux moteurs depuis les GPIO à l'aide d'une puce L293D;
• Déterminer la distance à un objet, avec un capteur de distance infrarouge Sharp, ou un capteur de distance ultrasonique Maxbotix (en utilisant un MCP3008 dans les deux cas);
• Alimenter un Raspberry Pi de façon autonome, sans secteur, avec des piles/batteries AA et un convertisseur de tension efficace, et tests d'autonomie;
• Commander des servomoteurs en utilisant la PWM logicielle de wiringPi, sans composants supplémentaires.

Merci aux contributeurs, pour l'instant, Yaug :)
Bien sur merci aux lecteurs de vos retours

Modifié par sky99, 11/04/2013 - 02:33.

[Killator]

Un topic qui risque de devenir rapidement une mine d'informations utiles sur le Raspberry !

Continu comme ça et je vais me sentir obliger de ressortir mon fer à souder !

[sky99]

Avant d'entrer dans le vif du sujet, voyons un peu ce qu'est le Raspberry Pi, et pourquoi tant de monde s'y intéresse à ce point.
En premier lieu, qu'est ce que c'est?
Pour faire simple, le Raspberry Pi est un très petit ordinateur, très économique et à faible consommation électrique. Je dis bien un ordinateur,
au sens générique, car ce n'est pas un PC : il est basé sur un processeur ARM plutôt que X86.
Le processeur ARM
ARM, c'est une architecture de processeurs qui est très appréciée dans le milieu de l'embarqué pour son bon rapport performance/consommation. On trouve des ARM dans les téléphones, les tablettes, mais aussi depuis de très nombreuses années dans les décodeurs, les voitures, les lecteurs MP3, les routeurs, modems, points d'accès wifi, les imprimantes, et beaucoup d'autres appareils embarquant un processeur. Ils sont peu chers, consomment peu, et on en trouve toute une gamme de diverses puissances. Pour un constructeur, c'est donc un choix intéressant puisqu'il est possible de dimensionner précisément le processeur pour l'appareil : on minimise ainsi les coûts, l'enveloppe thermique et électrique du produit, rendant le design plus simple et encore moins coûteux. Le seul domaine ou les processeurs X86 dominent généralement, c'est sur la puissance brute. Mais même cela pourrait changer.

En pratique, cela implique pour le Raspberry Pi que celui ci n'a pas besoin de système de refroidissement : ni radiateur, ni ventilateur. Donc silence total. Pas de pièce mécanique non plus, donc un plus faible risque de panne.

De plus la consommation est très faible : 700mA au maximum en 5v pour le modèle B, et moins de 400mA pour le modèle A, toujours en 5V. Cela représente donc 3.5W au maximum pour le modèle B, et moins de 2W pour le modèle A. Nous reviendrons plus tard sur les différences entre le modèle A et le modèle B. Enfin, tout ceci a permis un design simple et économique (même si l'ensemble a été fortement pensé dans ce sens!), ce qui fait qu'en pratique, un Raspberry Pi modèle B vaut 35$, et un modèle A vaut 25$.

Les versions du Raspberry Pi
Le Raspberry Pi est accompagné de 256Mo de ram pour le modèle A, et les versions 1 du modèle B. Les versions actuelles du modèle B ont 512Mo de ram.
Tous les modèles possèdent un port micro USB pour l'alimentation (les broches data ne sont pas connectées, seule l'alimentation électrique passe par ce connecteur), une sortie HDMI supportant le CEC (nous reviendrons dessus plus tard), une sortie S-video, une sortie audio jack stéréo et des broches GPIO (on en reparlera en détail). Il y a également un port SDHC qui peut recevoir des cartes SD/SDHC (il faudrait vérifier si le SDXC est géré) sur lesquelles l'OS sera installé.
Le modèle A a en plus un port USB 2.0, tandis que le modèle B à deux ports USB 2.0, ainsi qu'un port réseau fast ethernet (10/100, en RJ45).
Je ne détaille pas outre mesure, mais diverses petites modifications ont été apportées aux Pi, par exemple les trous de fixation, ou de nouveaux GPIO sur la revision 2.0.
Pour plus de détails, la page Wikipedia sur le Raspberry Pi détaille les évolutions de celui ci.

Voici la photo d'un Raspberry Pi modèle B, en révision 1 (il n'y a pas le connecteur P5 qui rajoute des ports GPIO) :


D'ou sortent les Raspberry Pi?
Le Raspberry Pi a été créé par la fondation Raspberry Pi, dont le but est de rendre l'informatique et son apprentissage accessibles. La fabrication industrielle est réalisée par Sony (au moins une partie en tous cas), avec plus d'un million d'exemplaires produits. Plus d'infos sont disponibles sur le site de la fondation Raspberry pi.

Passons maintenant à des questions plus pratiques.
Pourquoi un tel engouement?
Le prix, l'encombrement, et la consommation très faibles en font un produit de choix pour faire des applications embarquées, ou des serveurs de toutes sortes ne demandant pas trop de puissance. Un serveur web, un serveur d'impression, un serveur FTP, ce sont autant de tâches classiques qu'il est très appréciable de pouvoir confier à un Raspberry Pi. Fort logiquement, beaucoup s'y sont également intéresses car cela évite de bloquer un PC juste pour ça. Et le travail sera fait sans bruit, en étant dans un coin, et sans consommer des dizaines de watts.
Linux!
Outre cela, nous avons une carte assez ouverte, puisque pensée pour fonctionner avec Linux. Certes, il existe des dispositifs Android plus puissants, mais ils sont aussi plus chers, et sous Linux, on a tout de même un contrôle absolu par rapport à un Android pensé pour les terminaux mobiles. Inutile de partir dans un débat enflammé : oui on peut faire beaucoup de choses avec android, et rooter un terminal android pour en faire encore plus. Mais un "vrai" linux apporte beaucoup de possibilités qu'il est souvent complexe voir impossible d'obtenir sous Android.
La connectique embarquée permet également d'envisager de multiples usages (média center, serveurs réseau, etc) très faciles à mettre en place. Par exemple, il existe un portage de XBMC sur Raspberry Pi, avec RaspBMC. Il suffit d'installer l'image minimale sur la carte SD, de l'insérer dans le Raspberry, le connecter au réseau et de le démarrer. Apres quelques téléchargements , automatiques, vous disposerez d'un média center capable de lire de la full HD, d'indexer vos films/séries/clips/morceaux de musique/BD/etc en utilisant des bases de données en ligne, et le tout avec une magnifique interface graphique, et toutes les jaquettes des DVD/CD sont téléchargées automatiquement.
Le protocole CEC
Le protocole CEC est intégré à la norme HDMI, et lorsqu'un appareil le gère, il peut envoyer ou recevoir des commandes par le câble HDMI. En pratique, avec un Raspberry Pi, qui gère cette norme, sous RaspBMC, dès le premier démarrage, vous pouvez contrôler le Raspberry Pi avec la télécommande de votre télévision. Les touches lecture, stop, pause, avance rapide, retour rapide, et autres serviront enfin! Pour ma part, c'est le meilleur média center que je n'aie jamais eu. Et le meilleur, c'est qu'il est branché à ma télévision par un câble USB pour l'alimentation, un câble HDMI pour la vidéo et le son, et au réseau par un RJ45. Pas de clavier/souris à utiliser, rien d'autre! On peut également utiliser une clé wifi pour supprimer encore un câble, ou même simplement brancher une clé USB avec des média dessus...
Les broches GPIO
GPIO, cela signifie General Purpose Input/Output, soit Entrées-sorties à usage général. En pratique, les GPIO, sur le Raspberry pi, ce sont des broches (en haut à gauche sur la photo) sur lesquelles on peut connecter des "trucs", avec lesquels ont peut communiquer. On peut envoyer (sortie) ou recevoir des données (entrée) par ces broches. L'article de wikipedia sur les GPIO vous donnera plus d'informations sur les GPIO en général. En pratique, pour les domaines qui nous intéressent (robotique, domotique, automatisme, instrumentation, etc), ces broches nous serviront à brancher divers dispositifs que nous contrôlerons, ou qui nous fourniront des données. Avec les broches GPIO, on peut par exemple lire la valeur d'un capteur de lumière, d'un thermomètre, ou commander la rotation d'un moteur, ou d'un servomoteur. Et c'est la que le Raspberry pi passe de super cool à "über leet roxxor". Ce petit ordinateur à bas coût va nous permettre FACILEMENT d'interagir avec le monde réel.


Bon, que me faut il pour commencer?
Il vous faudra déjà un ou des Raspberry Pi. Il y a 3 fournisseurs officiels :

• Farnell/Element 14
• RS composants
• Allied Electronics

Dans tous les cas, vous trouverez la liste des revendeurs officiels sur http://www.raspberrypi.org.
Ces sites permettent de commander des Raspberry Pi et des accessoires. A certains moments, il y a eu des périodes assez longues d'attente (plusieurs semaines/mois), mais plus le temps avance, plus les stocks sont importants et les délais courts. Il est à noter que vous pourrez trouver des Raspberry Pi sur d'autres sites, tel que Adafruit, qui propose en plus de nombreux composants dont nous ferons bon usage ultérieurement. Les trois revendeurs officiels sont des sites de vente de matériel électronique. Ils ont des catalogues gargantuesques, avec des millions de références. Cependant, il est extrêmement difficile de "farfouiller" sur leur site pour choisir des composants, car les fiches sont souvent peu détaillées, et les sites semblent plus adaptés à des professionnels du domaine qu'a des amateurs/bidouilleurs voulant apprendre. Adafruit en revanche s'adresse beaucoup à cette cible, et les fiches sont donc très détaillées, avec des liens, des tutoriels, et surtout une sélection de composants qui nous intéressent presque tous. Même si vous achetez ailleurs, ça vaut le coup de regarder chez Adafruit pour voir ce qu'il y a en stock, et noter les références des produits intéréssants. Mais si vous n'avez pas envie de chercher, ne vous inquiétez pas, on fera des "packs" de composants intéressants pour quelques usages types. Le défaut d'Adafruit est que leur catalogue est bien plus restreint, et donc qu'on ne trouve pas toujours tout (mais pour débuter, il y a de quoi, largement), mais également qu'on ne peut commander que ce qui est en stock. Donc impossible de passer une commande qu'ils complètent quand les pièces arrivent pour tout recevoir en même temps. Du coup il faut parfois attendre la disponibilité d'un item pour commander, au risque qu'un autre ne soit plus en stock, ou faire des commandes multiples.

Ok, quoi d'autre que le Raspberry Pi?
Il vous faudra également une carte SD de 4Go ou plus pour Raspbian, et de 2Go ou plus pour RaspBMC. Plus la carte sera rapide, plus le système sera rapide à charger. Maintenant, j'ai utilisé une vieille classe 4, et je n'ai pas noté de lenteur particulière en SSH/partage réseau/serveur web. Le mode graphique risque davantage d'en pâtir.
Il vous faudra également un câble micro USB (la petite prise USB toute plate qu'on trouve sur les smartphones) mâle, ou un chargeur secteur ayant une sortie micro USB. La source (PC ou chargeur USB) devra délivrer au moins 700mA, mais 1A est la valeur recommandée. Le système peut fonctionner avec moins, mais autant prévoir un peu plus. Une autre solution intéressante est d'acheter un hub USB avec alimentation secteur et un câble micro-USB. Les alimentations des hubs sont souvent puissantes (les miens ont des alims de 3.5A, de quoi alimenter quelques pis!)
Un câble HDMI sera utile si vous voulez brancher le Raspberry sur un écran, un câble réseau pour brancher le pi sur le réseau, et un clavier-souris pour interagir avec le pi. Notez qu'il est parfaitement possible d'utiliser le Raspberry pi sans clavier/souris/écran, par le réseau. C'est ce que je fais : il est plus confortable de coder sur mon PC principal par le réseau et de lancer les commandes par ssh ou par un serveur web que sur le Pi lui même.

Avec ces éléments, vous aurez le minimum pour faire fonctionner un Raspberry Pi. Je récapitule donc:

• Un Raspberry Pi
• Une carte SD de 4Go ou plus pour Raspbian
• une source d'alimentation : un câble micro USB et un PC, ou un chargeur micro USB, ou un hub USB alimenté accompagné d'un câble micro USB
• Un câble HDMI si on souhaite brancher le PI à un écran,
• Un clavier/souris si on souhaite contrôler le pi directement
• Un câble réseau et/ou une clé wifi USB si le réseau est nécessaire (pour l'installation des paquets ce sera quand même plus pratique!).

Je vous préparerai bientôt des petits "packs" adaptés à des usages divers pour débuter, par exemple débuter en robotique, débuter dans l'instrumentation, etc. Mon but sera de faire des "packs" économiques, et permettant de s'amuser un peu, en comprenant les bases. On pourra envisager plus tard de faire des packs plus évolués.
A bientôt pour un prochain billet :)

[sky99]

Description des composants utiles pour commencer
Nous avons vu dans le post précédent ce qu'est précisément le Raspberry Pi, ainsi que le materiel requis pour s'en servir. Cependant, il s'agissait du minimum syndical requis pour faire fonctionner le Pi. Notre but n'étant pas de simplement faire un serveur, je vais vous présenter ici quelques équipements intéressants, et nous ferons des "packs" de démarrage.

Ou acheter?
En premier lieu, je vous recommande trois sites :

• Adafruit.com
• Pololu.com
• cooking-hacks.com

Ces trois sites proposent un catalogue très intéressant de composants adaptés aux besoins de la robotique, de la domotique, de l'instrumentation, et même de l'expérimentation en général. Les composants dont je vais parler sont souvent disponibles sur ces sites. Je mettrai souvent des liens vers Adafruit, car les fiches sont souvent très détaillées, avec des liens vers les tutos. Mais ce n'est pas toujours le moins cher, comparez.

Les composants
Les Arduino
Avant de commander, je voudrais vous parler des Arduino. Nous reviendrons peut être dessus ultérieurement plus en détails, mais sachez qu'il est possible de faire la plupart des projets que nous ferons ici de façon plus facile avec un Arduino. Par exemple, le Arduino Uno R3 est peu cher, et est une excellente plateforme pour apprendre et réaliser des montages plus ou moins complexes. Il possède 16 entrées sorties numériques et 6 analogiques. Par rapport au Raspberry Pi, ce n'est pas un ordinateur au sens classique, mais un microcontrôleur programmable. Avec le arduino on a un IDE, ou l'on peut taper du code en utilisant plein de librairies très pratiques pour faire des robots, des montages electroniques, des automatismes, etc. C'est une solution solide (il est plus résistant aux erreurs que le Raspberry pi), économique, à faible consommation, et pour laquelle existe une quantité astronomique de tutoriels. Pour beaucoup de projets, ce sera tout simplement plus facile et plus efficace avec un Arduino. Seulement, le raspberry Pi apporte un processeur beaucoup plus puissant, et on pourra par exemple analyser un flux de webcam avec le raspberry pi. Le arduino n'a même pas de port USB pour recevoir la webcam! En pratique il existe des shields pour Arduino qui permettent de rajouter des fonctionalités, mais dans tous les cas le microcontrôleur du arduino (un Atmel Atmega 328, a 20Mhz et ayant 32ko de mémoire si mes souvenirs sont justes) est incomparable avec l'Arm du Raspberry. Le raspberry a également un port réseau, une sortie HDMI, peut accepter des clés USB wifi, etc etc...
Le raspberry peut faire à peu près tout ce que fait le Arduino, mais le contraire n'est pas vrai. Cependant, rien ne vous interdit d'avoir les deux, c'est une fantastique platforme pour apprendre! Pour ma part, j'ai un Arduino uno R3, et 4 Raspberry pi. Enfin, le point ultime : il est possible de faire communiquer les deux par les ports GPIO pour combiner les forces des deux, mais aussi de brancher le Arduino en USB sur le Raspberry et échanger des informations par un port série. On peut ainsi faire un montage quelconque facilement sur le Arduino, et commander le système par le Raspberry. Cela sera particulièrement intéréssant pour les applications nécéssitant beaucoup de broches PWM, le raspberry n'en ayant qu'une. Mais nous reviendrons dessus, et il existe d'autres solutions. Pour ma part, je n'utilise presque plus le Arduino (il est dans l'un de mes robots, mais tous les suivants sont/seront commandés par les pi, ne serait-ce que pour communiquer en wifi, streamer le flux webcam du robot, échanger des infos entre les robots, etc.)


Pour les applications ou l'on souhaite combiner les capacités d'un Arduino avec celles d'un Raspberry pi, il existe une autre solution, plus économique, et assez classe : intégrer uniquement le contrôleur du Arduino (Atmel Atmega 328 avec bootloader Arduino) dans un circuit communiquant par GPIO avec le Pi. Cette solution est plus économique (la puce coute 6$ sur adafruit avec le bootloader arduino dedans), moins consommatrice d'énergie (sans les composants supplémentaires, le Atmega consomme bien moins), mais plus complexe à mettre en oeuvre, puisqu'il faudra soit un Arduino pour programmer la puce, soit un programmateur AVR. Pour ma part j'ai un Arduino, et la puce, de sorte que j'utiliserai l'Arduino pour programmer la puce, et en attendant la puce sert de puce de rechange si je grille le Atmega de mon Arduino. Dans tous les cas, ces précisions ne doivent pas être prises pour des recommandations d'achat : c'est honnêtement quelque chose dont vous risquez de ne pas vous préocuper avant longtemps. En revanche, si c'est pour faciliter l'introduction à l'électronique, et que ça ne vous dérange pas de dépenser 30$ pour ça, ça vaut totalement le coup. D'autant plus que tous les composants complémentaires que nous rajouterons seront utilisables avec le Raspberry. En revanche, le Arduino risque de traîner sur une étagère quand vous passerez aux Pi, jusqu'a ce que vous ayez une super idée de projet combinant les 2 :).
Au passage, sur PCI, un autre INpacticien, critok, a déjà un robot Arduino autonome, qui communique avec un PC en USB : Le projet Daryl.

Les Breadboard
Une breadboard, ou plaque de prototypage sans soudure, et une plaque dotée de nombreux trous. Ces trous peuvent recevoir les pattes de composants électroniques divers. Dans chaque trou, il y a un petit système de pince à ressort qui serre la patte du composant pour assurer le contact. Cela permet de tester des montages électriques facilement, sans faire de soudure. C'est un outil formidable pour l'expérimentation. L'avantage est qu'en plus, vous pourrez faire un circuit pour apprendre quelque chose, puis défaire le circuit pour réutiliser les composants à autre chose. En gros, on peut le voir comme le Lego de l'électronique. Sauf qu'on utilise des composants électroniques ordinaires, donc avec une breadboard on peut s'amuser avec les composants électroniques dont on dispose déjà.
Le principe est le suivant :

La plaque que vous voyez est une breadboard avec à droite un schéma superposé dessus. Les lignes jaunes représentent les pistes électriques de la plaque. Cela signifie que sur la plaque présentée à gauche, si vous branchez quelque chose en haut à gauche, en 1a (cliquez sur l'image pour voir la breadboard en plus grand), cet élément sera connecté électriquement aux trous 1b,1c, 1d et 1e. Cela permet de relier deux composants entre eux par exemple. Sur les cotés, vous noterez des trous organisés différemment. Il s'agit des rails d'alimentation. En fait vous en faites ce que vous voulez, mais ils sont prévus pour avoir le + de l'alimentation électrique du circuit, et le -. La différence est que le rail part du haut vers le bas de la plaque, plutôt que de droite à gauche.
Il existe différentes tailles de breadboard, avec ou sans rails. Par exemple, les Tiny breadboards, les half size breadboards, les full size breadboards, et les large breadboards. De mon point de vue, les plus intéressantes sont les "half size", car on peut en accrocher 2 ensembles pour en faire une grande, elles ont des rails (amovibles), et on a rarement besoin de plus de place. Je vous recommanderai d'acheter deux half size plutôt qu'une large, si votre circuit est complexe, il suffira d'utiliser les deux, dans le cas suivant ça vous permettra de faire un nouveau montage sans défaire l'ancien. Les modèles "tiny" sont surtout intéressants pour faire de petits montages lorsqu'on a des contraintes d'espace, ou pour ne pas gâcher une breadboard complète à un montage simple qui se retrouvera dans un coin. Par exemple si vous faites un circuit pour l'alimentation électrique, et que celui ci se retrouve dans une trappe du robot, il sera difficile d'y accéder pour rajouter des puces. Une tiny breadboard fera donc l'affaire, et la half size restera sur le dessus pour recevoir des capteurs. Parmi les 3 sites, les meilleurs prix en breadboards sont chez pololu : 3.75$ la half size, 4.95 la full size, et 2.95 la tiny. Je vous déconseille la Large dans tous les cas, autant prendre 3 full size, ou 6 half size, ce sera pareil pour moins cher.

Les "Jumper Wire"
Ces câbles servent à connecter les broches GPIO a des dispositifs, sans risque de court-circuit, de façon non permanente, mais aussi à connecter des lignes de la breadboard entre elles, ou un composant ayant des broches ou des trous à la breadboard. Les prix sont bons sur Adafruit. Il y a globalement trois types de jumper wire qui nous seront très utiles :

• les "breadboard jumper wire", ou les male-male jumper wire, assez indispensables (l'un des deux suffit), car ils permettront de connecter deux lignes de la breadboard. Ils existent en différentes tailles. Pour connecter des éléments de breadboard, les plus courts suffisent. Le second type de câble me semble plus solide après quelques mois de tripatouillage.
• Les "female-male extension jumper wire", qui ont un coté femelle que l'on branchera sur le Raspberry pi et un coté mâle qui ira sur la breadboard. Indispensable si vous n'avez pas de "Pi Cobbler" (nous reviendrons dessus plus tard)
• Les "female-female jumper wire" ont deux prises femelle, et peuvent se brancher sur des broches GPIO et de l'autre coté sur un dispositif ayant une prise mâle. Généralement on passe par la breadboard, pour mettre une résistance en série, un convertisseur DAC ou autre. Toutefois, vous pouvez combiner ces câbles avec les "male-male" pour faire un "male-female", ou utiliser ces headers extra longs pour connecter le pi à la breadboard, remplaçant les "male-female"

J'ai également parlé du Pi Cobbler. il n'est pas indispensable, et nécessite de la soudure. En revanche, une fois réalisé, il permet de connecter le PI à votre montage en un coup par une nappe du genre des nappes de lecteurs de disquettes. Pratique si vous avez un pi et plusieurs montages. Deux versions existent :

• Le Pi Cobbler, qui est le plus compact, mais dont le design n'est pas le plus lisible (la nappe passe devant les broches)
• Le Pi-T-Cobbler, qui est plus encombrant, mais met la prise de la nappe plus loin pour ne pas gêner la vision du circuit. Si c'était à refaire, je prendrais cette version plutôt que l'autre, même si l'autre à d'autres avantages.

Dans tous les cas, c'est sympa à avoir, mais ça "mange" de la place sur la breadboard (13 trous, sur 2 rangée, donc près de la moitié d'une half-size). Ce n'est pas du tout indispensable, à vous de voir selon vos idées. Par contre, pour un montage "permanent", c'est une connexion bien plus solide que les jumper wire, et on ne peut pas se tromper de broche (par contre on peut se tromper de sens de branchement sur le pi, mais il n'y a que deux possibilités, donc il est rapide de vérifier cela!)

Nous avons maintenant la base qui nous permettra de faire des circuits. Ce qui nous manque maintenant, c'est d'avoir des éléments à connecter dessus. Commençons par les éléments les plus simples :

Les LED
Les LED ou DEL en français, pour Diodes Electro-Luminescentes, sont des composants polarisés, c'est à dire qu'ils ont un + et un -. Quand la tension (volts) adéquate est appliquée aux bornes d'une LED, et dans le bon sens, celle ci produit de la lumière. Certaines sont faites pour éclairer (LED haute puissance), d'autres pour signaler (l'appareil est allumé, les données sont reçues, etc). Nous nous en servirons surtout pour tester certains montages, et parce que celles ci ont un coût dérisoire. La première chose qu'on fera sera de faire clignoter une LED, ce que d'aucuns considèrent comme le "hello world de l'électronique".

Il en existe de toutes les couleurs ou presque, et même des modèles multicolores.
En pratique, choisissez la couleur qui vous plait :
Blanc, rouge, bleu, vert, jaune, et même tricolore. A noter que les LED tricolores sont en gros 3 LED dans un seul boitier. Il y a 4 pattes : une pour le moins, et une pour le + de chaque couleur pour les modèles common cathode. Préférez ces modèles, ils sont plus simples à programmer avec des GPIO. Adafruit aussi a toutes sortes de LED, mais souvent par paquet. Les liens que j'ai donné sont pour des LED de 5mm de diamètre, mais il existe aussi des LED de 3mm, de 10mm, et sans doute d'autres tailles plus dures à trouver.
Au passage, il existe aussi des couleurs invisibles : infrarouge, ou encore ultraviolet. Pour ma part, je n'ai pas trop d'idées de projets pour des LED UV (on pourrait bien faire le détecteur de billets qu'ils présentent, ou essayer de faire pousser des plantes, mais ça ne me motive pas plus que ça), mais en infrarouge, on peut commander une télé, un décodeur canal sat, ou n'importe quel appareil ayant un récepteur infrarouge.
Enfin, on peut utiliser les LED IR avec un récepteur pour communiquer entre deux robots, ou entre un robot et une balise. Les LED ont une tension (volts) spécifique qui est nécessaire à leur bon fonctionnement:

• environ 2.2V pour les LED rouges (en 20mA)
• environ 2.2V pour les LED vertes (en 20mA)
• environ 3.0V pour les LED bleues (en 20mA)
• environ 2.2V pour les LED jaunes (en 20mA)
• environ 3V pour les LED blanches (en 20mA)
• environ 1.6V pour les LED IR

D'autres LED peuvent demander une tension plus forte, ou plus de courant (les mA), par exemple pour les "ultra bright", ou ultra lumineuses.
Il est à noter que les LED bleues et blanches sont souvent plus chères, consomment plus de courant et sont plus lumineuses que les rouges, jaunes et vertes.

Une LED doit être alimentée par la bonne tension, et pour cela on utilise souvent une résistance en série pour alimenter la LED. Dans le cas du Raspberry, on pourra se passer de résistance si on alimente une LED bleue ou blanche depuis les GPIO, et il faudra idéalement une résistance de 55 Ohms pour alimenter une led rouge, jaune ou verte. En pratique, les résistances standard de 47Ohms feront l'affaire.

Au passage, de nombreux tutoriels existent sur les LED, je ne vais pas m'appesentir dessus.
Si vous avez un magasin d'électronique pas loin de chez vous, nul besoin de commander les LED, elles sont très faciles à trouver. Peut être moins pour les led IR, UV, RGB, ou les leds "spéciales" qui changent de couleur toutes seules, mais la plupart des leds sont faciles à trouver et peu chères.

Les résistances
On en a parlé un peu avant. Les résistances serviront à, en gros, abaisser la tension apportée à un composant (par exemple une LED). Il y a de grandes chances qu'on en aie besoin à un moment ou un autre de résistances (aussi appellées résistors). C'est un composant non polarisé, c'est à dire que vous pouvez le mettre dans n'importe quel sens. Leur valeur est donnée par un code de couleurs. Les valeurs des résistances du commerce sont également définies par une norme : en pratique, on ne trouve pas toutes les valeurs possibles. Dans la pratique, essayez d'avoir quelques résistances de diverses valeurs, par exemple, pour les LED, et pour 2-3 autres usages. En pratique, il nous faudra probablement des résistances pour:

• Les LED : 47Ohms en 3.3v pour les jaunes, rouges, vertes
• Des résistances de tirages, dites pull up et pull down lire la valeur de boutons et d'autres dispositifs : 2.2K, 4.7K , 10K
• peut être quelques résistances diverses selon des besoins spécifiques que vous aurez calculé

Si vous comptez alimenter vos LED en 5v, il vous faudra des résistances adaptées, et refaire les calculs.
Quelques puces
Le MCP3008 : lisez des capteurs analogiques avec votre Raspberry
Le Raspberry pi possède un certain nombre de d'entrées-sorties par le biais des GPIO. Mais tous ces GPIO sont numériques, c'est à dire qu'ils ne peuvent lire que des 0 et des 1,
ou suites de 0/1. Certains capteurs sont numériques, et envoient des informations dans ce format, mais la plupart des capteurs envoient des données analogiques, c'est à dire
qu'ils enverront une tension particulière pour indiquer la valeur du paramètre mesuré plutot qu'un code numérique. Par exemple, un capteur de température pourra retourner
2.225v pour indiquer que la température est de 30°C, et 2.233 pour 40°C (c'est un exemple au pif). Le problème est que le pi ne saura pas lire et interpréter ces valeurs. C'est pour cela
que nous utiliserons un ADC (Analog to Digital Converter, convertisseur analogique vers numérique). Il existe de très nombreux composants permettant cette conversion, mais je
vous parlerai ici du MCP3008, car je le connais, et que je vous fournirai un tutoriel en français sur son cablage vers un PI, sa programmation et son utilisation.
Pour moins de 4$, cette puce utilise 4 GPIO du Raspberry pi, mais vous donne 8 entrées analogiques en échange, qui vous permettront de lire autant de capteurs analogiques.
A noter que si vous n'avez pas la patience d'attendre mon tutoriel, Adafruit a un tuto sur l'utilisation du MCP3008, en anglais. Les GPIO utilisés sont ceux du port SPI.
Je vous conseille d'en prendre un par Raspberry pi avec lequel vous souhaitez lire des données analogiques. Nous verrons dans le prochain post divers capteurs analogiques (et aussi numériques).

Ajoutez 8 ou 16 GPIO au Raspberry grâce au MCP23008 ou au MCP23017
Le PI a un nombre limité de GPIO. Toutefois, en utilisant un MCP23008, il est possible au prix de 2 GPIO d'en rajouter 8, et toujours pour 2 GPIO, on peut en rajouter 16 avec le MCP23017. Ces deux GPIO sont ceux du port I²C, et ne sont pas "perdus", car c'est un BUS sur lequel on peut connecter de multiples puces. On pourra ainsi brancher encore d'autres MCP23008 ou MCP23017, ou d'autres puces I²C.
Si vous souhaitez commander de nombreuses LED, ou un écran LCD texte (ils consomment généralement 6 GPIO, voire 9 avec un rétroéclairage RGB contrôlé par le pi) ordinaire, ou encore si vous voulez ajouter plein de boutons.
La différence entre les deux est que le MCP23008 ajoute 8 ports, et a 16 pattes, contre 16 ports pour 14 pattes pour le MCP23017. A moins d'avoir des contraintes d'espace (un petit circuit avec peu de place), je ne vois pas de raison de ne pas prendre le MCP23017 au lieu du MCP23008, d'autant que les prix sont très proches.
Dans tous les cas, je ferai d'abord un tuto sur le câblage et l'utilisation du MCP23017, puis un petit add-on pour le câblage du MCP23008 (le câblage change, mais le code reste identique)

Un changeur de niveau logique : le 74LVC245.
Le 74LVC245 est un "logic level shifter", ou ajusteur de niveau logique. En pratique, si vous avez des capteurs numériques, des puces, ou encore d'autres dispositifs numériques qui fonctionnent avec un niveau logique de 5V (0V correspond à un 0, et 5V à un 1, avec une certaine marge), le PI n'aimera pas recevoir des signaux de 5V sur ses GPIO, pour qui le +3.3V correspond à un 1. La solution est d'utiliser une puce qui fait la conversion. Il y a des chances que vous n'en ayez pas besoin, je ne me suis pas encore servi des miennes. Toutefois, la puce ne coûte presque rien, et je trouve plus pratique d'en avoir au moins une sous la main "au cas ou". En pratique, beaucoup de puces sont capables de travailler avec des niveaux logiques de 3.3V, donc ce n'est pas nécessairement indispensable, et vous pouvez aussi bien vous en acheter une lorsque vous achèterez le composant qui en aura besoin.

Une puce pour contrôler un ou deux moteurs : la L293D
SI vous contrôlez un moteur depuis les ports GPIO du PI (ce qui sera nécessaire pour un robot), vous pourrez faire tourner ou non le moteur. De plus, il faudra des transistors
pour donner assez de courant au moteur (les GPIO ne sont pas faits pour donner de la puissance, mais un signal logique). Si vous souhaitez faire tourner le moteur dans l'autre sens,
il faudrait inverser le câblage. Le L293D est une puce dédiée à ce genre d'opérations. Cette puce permet de contrôler deux moteurs alimentés par 4.5V à 36V, fournis par une seconde source, avec les signaux GPIO du PI. Chaque moteur pourra utiliser jusqu'à 600mA. Le L293 quand à lui accepte 1A par moteur. Il existe également d'autres puces, telles que le SN754410, qui peut sortir 1A par moteur en continu. J'ai un tuto sur le L293D dans les tuyaux, et j'en ferai un sur le SN754410 dès que je l'aurai utilisé (pour l'instant je dois vérifier les spécifications). A noter qu'il est possible de combiner deux L293D ou davantage pour plus de puissance vers les moteurs.

http://learn.adafruit.com/system/products/images/000/000/593/medium225/mcp23008_MED.jpg?1342023679 http://learn.adafruit.com/system/products/images/000/000/732/medium225/ID732_MED.jpg?1342023457http://learn.adafruit.com/system/products/images/000/000/807/medium225/ID807_MED.jpg?1342023300
De gauche à droite : le MCP3008, le MCP23008, MCP23017, et le L293D. Les liens sur les images mènent à des tutos en anglais.


Nous allons maintenant passer aux capteurs, qui nous permettront de prendre des informations provenant du monde matériel.

Modifié par sky99, 27/01/2013 - 19:50.

[sky99]

Les capteurs
Il existe deux grandes catégorie de capteurs : les capteurs numériques, et les capteurs analogiques. Les premiers communiquent au format numérique avec votre appareil, selon un procotole quelconque, tandis que les seconds renvoient une valeur analogique qui est fonction du paramètre mesuré. Les capteurs numériques coutent généralement plus cher que les capteurs analogiques, et requièrent d'utiliser un protocole bien précis. Les capteurs analogiques sont moins chers, et la valeur peut simplement être lue, mais en revanche, il faudra un convertisseur ADC (tel que le MCP3008, voir post précédent). Cependant, un MCP3008 peut lire les données de 8 capteurs. Je vais vous présenter principalement des capteurs analogiques, car je les trouve plus simples à utiliser, mais on peut toujours rajouter tous les capteurs numériques qui vous paraissent intéressants!

Commençons par le capteur le plus simple qui soit :
Le bouton poussoir et l'interrupteur.
Non, ce n'est pas une fable de la fontaine
Un bouton poussoir est un bouton à changement d'état temporaire, c'est à dire que si vous appuyez, l'état change, et quand vous relâchez, l'état revient à la valeur initiale. Par exemple un bouton poussoir qui par défaut est sur "off", passera sur "on" quand on appuiera sur le bouton, et jusqu'à ce qu'on le relâche. Au contraire, un interrupteur changera d'état quand on l'actionne, et restera dans le nouvel état jusqu'à ce qu'on l'actionne à nouveau. Dans les deux cas, on pourra lire l'état du bouton avec un GPIO du Raspberry pi (ou avec ceux ajoutés par un MCP23008 ou MCP23017, voir post précédent). Par exemple, vous pourrez avoir une webcam branchée au pi, et lorsque vous appuyez sur un bouton poussoir, elle prend une photo, ou bien avec la même webcam, quand vous mettez un interrupteur sur "on", elle prend des photos toutes les secondes pour faire un timelapse, et arrête de prendre les photos quand l'interrupteur repasse sur off. Il existe toutes sortes de boutons poussoirs :

• Les plus simples en 6mm pour circuits, ou les mêmes en 12mm, qui peuvent aller sur breadboard (voir le post sur les composants de base);
• De plus gros modèles, colorés;
• Des modèles qui s'illuminent quand on appuie dessus;
• Des modèles anti-vandalisme en métal chromé avec led intégrée,

Mais il existe aussi des boutons qui seront directement adaptés à la robotique :

• Bouton avec levier de 5cm;
• Bouton avec levier à roulette;
• Bouton avec levier à bosse.

Ces boutons fonctionnent exactement comme des boutons poussoirs, mais ont un levier qui appuie sur le bouton de taille plus ou moins importante, et permettent ainsi d'en faire de parfaits détecteurs de contact. Imaginez le levier comme les moustaches d'un chat!
Il y en a de toutes sortes :
http://www.cooking-h...rs/buttons.html
https://www.adafruit...search&q=button

A vous de voir ce qui vous intéresse!
Il existe de même toutes sortes d’interrupteurs, des ronds, rectangulaires, avec 2 ou 3 broches... Il faut un modèle 2 broches pour allumer/eteindre un circuit, mais les modèles 3 broches le peuvent aussi. Assurez vous seulement qu'il s'agit d'un interrupteur (parfois décrit comme "on-off button") et pas d'un bouton poussoir (momentary pushbutton).
Ces boutons ne coûtent pas trop chers, je vous conseille d'en prendre quelques un pour en avoir sous la main. Si vous voulez à terme les fixer sur le boitier de votre montage, prenez ceux qui ont des fixations prévues pour, les petits boutons tactiles, interrupteurs, etc sont souvent prévus pour être simplement soudés sur un circuit ou inséré dans une breadoard. Vérifiez également qu'ils peuvent s'insérer dans une breadboard, c'est généralement précisé. Dans le cas contraire, il faudra ajouter des fils.

Les capteurs généraux
Voyons maintenant quelques capteurs à usage général qui peuvent être intéressants.

Capteurs de température
Un bon capteur de température, économique et simple à utiliser, est le TMP36.

Sur la photo ci dessus, on voit le capteur, et le branchement à effectuer. La patte de gauche sera connectée sur le +3.3V du Raspberry, la patte centrale sur une broche du MCP3008, et la broche de droite sur la masse (0V) du Raspberry. Il est extrêmement facile d'utiliser ce capteur, et on peut en mettre plein si on veut. Par exemple sur les moteurs pour verifier les surchauffes, dans votre PC pour mesurer la température ambiante, bref, ou vous voulez (dans les limites des spécifications, et pas dans l'eau sans protection!)

Il existe aussi des thermistances : ce sont des résistances dont la valeur varie en fonction de la température. Cette thermistance coulée dans l'époxy peut mesurer des températures jusqu'a 105°C et peut aller dans des liquides.

Enfin, si vous souhaitez mesurer de hautes températures (jusqu'à 500°C!) il est possible d'utiliser ce genre de résistance thermocouple. Mais là, les prix montent ^^

Pour des mesures "classiques", la TMP36 est votre meilleur choix : elle est simple, (il faudra faire un petit montage avec les autres, pas très compliqué, mais il faut quand même le faire, plutôt que simplement brancher 3 fils), économique (la moins chère des 3), fiable, et assez précise. Il est toujours possible de souder vos câbles, et de couler le tout dans de l'époxy pour la rendre submersible...

Capteur de lumière/luminosité
Les photorésistances sont ces composants dont la résistance varie en fonction de l'intensité lumineuse qui frappe la surface réactive.

Ce capteur est simple à utiliser, et peut servir à détecter le jour et la nuit, mais aussi à mesurer l'intensité lumineuse. Avec quelques uns de ces composants peu coûteux, on peut déterminer la provenance d'une source lumineuse, et par exemple orienter un panneau solaire vers le soleil pour en tirer un rendement maximum!
Il existe d'autres capteurs de luminosité, plus précis, qui peuvent donner la valeur en lux du rayonnement reçu, mais ils sont plus chers. De plus, cette précision est utile si l'on veut des mesures calibrées, mais ici, une échelle arbitraire suffit souvent pour de les mesures simples dont on aura besoin.


Les capteurs de distance
Les capteurs de distance serviront à déterminer la distance entre un objet et le capteur. Il existe deux technologies courantes pour faire cela : les capteurs infrarouge, et les capteurs ultrasoniques

Les capteurs infrarouges
Ils sont généralement adaptés à la détection d'obstacles sur de courtes distances (10 à 80 cm pour le GP2Y0A21YK0F, et 20 à 160cm pour le GP2Y0A02YK). Le faisceau est très étroit, et il sera capable de détecter des objets fins comme un pied de chaise. Ces capteurs sont économiques, mais doivent etre montés sur un servomoteur pour balayer devant le robot, ou être utilisés à plusieurs. Il est à noter qu'en dessous de la distance minimale, vous lirez des données fausses sans avoir le moyen de savoir qu'elles sont fausses. Une solution est donc de placer ce capteur à l'arrière de votre robot, sur un mât, de sorte que la distance à l'obstacle soit toujours au moins la longueur du robot... Pour mon premier robot, R. Berion, j'ai utilisé un tel capteur. On peut voir sur la vidéo qu'il évite (à peu près) les obstacles. Il lui manque le balayage de l’environnement, et donc c'est très imparfait. Voici un apperçu du résultat :

Il existe également des capteurs similaires pour de plus courtes distances, par exemple, le Sharp GP2D120XJ00F, mesurant de 3 à 40cm, ou encore des capteurs Sharp pour des distances de 2 à 10cm avec le GP2Y0D810 et de 0.5 à 5cm avec le GP2Y0D805. La, il s'agira plutot de détecter des objets quasi en contact avec le robot, ou en complément de l'autre capteur pour détecter les objets sous la distance minimale. Un autre usage peut etre de pointer le capteur vers le sol, à l'avant du robot, pour détecter s'il y a un vide. Ainsi, le robot serait capable d'éviter les escaliers/marches/trous.

Les capteurs ultrasoniques
Ceux ci sont plus coûteux, ont une fréquence de rafraîchissement plus basse (environ 20Hz), mais peuvent donner la distance jusqu'à 5-6m, avec une précision de 1pouce (2.5cm environ) pour le Maxbotix LV-EZ4, et une précision de 1mm pour le Maxbotix HRLV-EZ4. Le plus précis est bien entendu plus cher. Il existe d'autres références dans la même marque, mais ceux ci ont un faisceau plus large, et capteront donc plus d'objets simultanément et des moins facilement les petits objets. SI vous voulez un faisceau plus large, prenez le modèle correspondant à la précision souhaitée, avec le dernier chiffre plus bas : les EZ3 ont un faisceau plus large que les EZ4, et ainsi de suite jusqu'à EZ0.

Autres capteurs
Voici également quelques capteurs qui peuvent s'avérer utiles :

Récepteur infrarouge
Le TSOP38238 est un capteur numérique. Il est très économique, et peut être super utile. Il permet de capter des signaux infrarouges émis dans la bande de fréquence des 38Khz de signal porteur, soit la bande utilisée pour les télécommandes. On parle bien de lumière infrarouge, mais émise par "à coups", 38 000 fois par seconde. En pratique, cela signifie que vous pourrez capter les télécommandes de télévisions, sat, etc, sans avoir d'interférences dues aux autres sources infrarouges. Avec une LED IR, on pourra aussi émettre a 38Khz pour envoyer des informations vers un dispositif doté de ce récepteur. Et si l'on a décodé avec ce capteur les signaux des télécommandes, on pourra essayer d'en émettre avec le Raspberry pi pour allumer/éteindre les appareils!

Capteur de champ magnétique
Ce capteur US5881LUA détecte le pôle sud d'un aimant. Il peut servir à compter le nombre de tours par minute d'un dispositif rotatif, ou à vérifier si un système est bien fermé, et encore plein d'autres possibilités.
Il s'agit d'un capteur digital : soit l'aimant est en face du capteur; soit il ne l'est pas. Il est donc très simple à utiliser et ne nécessite pas de DAC.

Capteur de hauteur d'eau
Ce capteur analogique "TWIG WATER SENSOR" permet de savoir si de l'eau est présente, et à quelle hauteur. Intéressant pour mesurer si l'eau d'un réservoir atteint un seuil critique, par exemple...

Dans le prochain billet, nous verrons les "muscles" des robots : les moteurs et servomoteurs.

Modifié par sky99, 27/01/2013 - 21:48.

[sky99]

Si l'on souhaite bouger des choses, ou faire avancer un robot, nous devrons utiliser des dispositifs permettant de transformer l’électricité en mouvement.
Nous verrons deux catégories principales : les moteurs, et les servomoteurs.

Les moteurs
Un moteur est un dispositifs dont l'axe tourne quand on applique du courant à ses bornes. Je parle de moteur à courant continu, car bien sur il existe d'autres types de moteurs, mais qui ne seront pas des plus pratiques pour nos robots.
Si le courant est appliqué dans un sens (+sur la patte 1, - sur la patte 2), le moteur tournera dans un sens, et si on applique le courant dans l'autre sens (+ sur la patte 2 et - sur la patte 1), il tournera dans l'autre sens. Le moteur est prévu pour tourner avec une certaine plage de tension, et requiert une certaine intensité. Ces paramètres sont précisés dans les spécifications du moteur.

En attendant une mise à jour plus détaillée, voici quelques moteurs intéréssants :

• Pololu micro gearmotor 180:1 avec renvoi d'angle;
• Pololu micro gearmotor 180:1 avec axe droit;
• Pololu micro gearmotor 120:1 avec renvoi d'angle;
• Pololu micro gearmotor 120:1 avec axe droit;

Ces moteurs (il vous en faudra 2) devront être associés à des roues ou des chenilles :

• Chenilles compatibles;
• Roues de 60mm de diamètre;
• Roues de 90mm de diamètre;
• Roues larges;

Si vous avez des chenilles et deux moteurs, vous avez de quoi faire avancer un robot. Si vous avez choisi des roues, il vous faudra un troisième point de contact. Le robot aura deux roues, il manque donc un un appui supplémentaire. Pour cela on utilise un "ball caster", une bille dans un support qui peut tourner dans tous les sens. Cela permet au robot d'avancer en ayant une friction faible.
En voici quelques uns :

• 3 ball casters en plastique, pas chers;
• 2 ball casters à bille en metal, plus chers mais plus solides;

Il y a toutes sortes de tailles disponibles dans la section "ball casters" de pololu.
Plus la bille sera grosse, moins elle sera gênée par des petits obstacles.

Les servomoteurs
Un servomoteur est un système qui permet de faire tourner un axe selon un angle bien précis. Il y a 3 fils : le +, le -, et le fil de commande. Le fil de commande reçoit des impulsions qui indiquent au servomoteur de se tourner à un angle précis. Les servomoteurs ont un couple important, mais sont prévus pour tourner dans des limites (180° en général). Le servomoteur servira par exemple à orienter une caméra, un capteur, ou faire bouger un bras robotique. Si vous voulez faire un robot à pattes, il vous faudra quelques servomoteurs.
Il existe toutefois une catégorie spéciale de servomoteurs : les servomoteurs à rotation continue. Ceux ci peuvent tourner dans un sens, dans l'autre ou stopper selon la commande envoyée. Ils sont assez intéressants pour faire des robots car ils sont faciles à commander, ont un bon couple, et ne nécessitent pas de circuit de commande supplémentaire. Il suffit de les alimenter, et d'envoyer les signaux requis avec des GPIO. Le problème sera d'envoyer précisément la bonne durée d'impulsion avec le pi, dont le linux n'est pas un système temps réel, et donc des tâches diverses peuvent perturber la précision des influx envoyés.


Je détaillerai davantage divers moteurs et servomoteurs.

[sky99]

Voyons maintenant quelques packs.
Je rappelle que le but c'est d'avoir un peu de matériel, sans dépenser trop, et de façon à pouvoir faire quelques petits projets sympa.

Pack mesures météo
Le but de ce pack, ce sera de mesurer diverses choses, pour le simple plaisir de savoir, ou pour des applications plus concrètes.
Il nous faudra donc :

• Un Raspberry Pi - 30€
• Une SD 4Go ou plus - 5€
• un câble micro USB - 2.5€
• Une breadboard (ou deux) -3/6€
• Un MCP 3008 - 3€
• Des jumper wire mâles-mâles -5€
• Des jumper wire mâles-femelles -5€
• quelques TMP36 - 5€
• des photorésistances - 5€
• deux capteurs de champ magnétique US5881LUA - 3€
• un ou deux récepteurs IR - 2/4€
• quelques LED infra-rouge 2/3€
• Quelques résistances - 2/3€
• Quelques LED - 3/4€
• Un MCP23017 pour ajouter des GPIO si besoin - 2.5€

Au total, on s'en sort tout compris pour moins de 100€. Avec ça on peut déjà fabriquer un anémomètre, mesurer la luminosité du soleil, fabriquer un pluviomètre, mesurer la température en divers endroits, en gros, faire une station météo... J'ai pris des capteurs pour faire un pack, mais bien sur vous pouvez choisir d'autres capteurs, pour d'autres usages... Il est également possible de rajouter un écran LCD 4*20 caractères pour environ 20€ ou un LCD 2*16 caractères pour environ 10€ pour afficher des trucs depuis le PI, et ne plus avoir besoin d'écran. Si vous ajoutez quelques boutons, cela peut faire une station de mesure autonome...
EN pratique, ça peut donner ça :


Kit robot économique
Le but est de faire un petit robot autonome, économique, basé sur le Raspberry Pi.

• Un Raspberry Pi - 30€
• Une SD 4Go ou plus - 5€
• Un câble micro USB - 2.5€
• Un adaptateur usb-power jack - 2.5€
• Une breadboard (ou deux) -3/6€
• Deux moteurs - 8€ avec ( 2 roues (6€) et un ball caster (2€)) OU (des chenilles - 10€) soit 16€ ou 20€
• Un capteur de portée IR (11€) OU un capteur de portée ultrasonique - 20€
• Un micro servo 3 à 7€
• Un MCP 3008 - 3€
• Deux L293D ou un TI SN754410 - 4€ ou 3€
• Un bloc pour 6 batteries AA - 1.5€
• Un régulateur 5V - 5€

En pratique, on a donc de quoi faire un robot autonome pour 85€ à 100€ selon les options.
Ce robot sera capable de fonctionner en autonomie avec 5 ou 6 batteries AA rechargeables de se déplacer à vitesse variable, et d'éviter des obstacles.

Modifié par sky99, 28/01/2013 - 01:43.

[sky99]

Installation de Raspbian
Maintenant que nous avons un Pi, et une carte SD de 4Go ou +, on peut installer Raspbian.
Si vous êtes sous Windows, il suffit de télécharger win32DiskImager, ainsi que Raspbian (qui est en fait un portage de Debian sous Raspbery Pi. Et Debian, C'est bien!).
Mettez votre SD dans un lecteur SDHC quelconque, lancez Win32DiskImager, ouvrez l'image décompressée, et cliquez sur "Write". Notez qu'une fois Raspbian installée et configurée aux petits oignons,
il est possible de faire l'opération inverse, en sauvegardant la SD vers un fichier. C'est ce que j'ai fait, de sorte que les paquets supplémentaires, le code, les cron, etc, sont également sur mes nouvelles cartes.
Cela fonctionne également pour upgrader la carte SD.

Bref, une fois la copie faite, mettez la carte dans le Raspberry Pi, alimentez le, et Raspbian bootera! Au premier démarrage, il lancera raspi-config, qui permettra de définir les paramètres du système. Il est possible à tout moment de relancer raspi-config pour changer les paramètres, par exemple désactiver ou activer l'interface graphique. Il suffit de suivre les menus, mais je détaillerai ultérieurement le processus de configuration.

Une fois le démarrage effectué, le Raspberry Pi est opérationnel!
Avec SSH et samba, il est possible de lancer des commandes et d'administrer le pi à distance, et également d'éditer les fichiers en mode graphique depuis un "gros" pc, ou encore de copier/transférer les fichiers.
Pour ma part j'ai également rajouté apache+php+mysql, avec les extensions GD, et je peux ainsi commander le pi par un navigateur web.

Cet article est un rapide résumé, je l'étofferai ultérieurement.

[sky99]

Bon, maintenant, on a bien parlé de trucs et de machins divers, il est temps de passer aux choses "sérieuses", et de faire quelque chose de concret.

Faisons clignoter une LED/contrôlons la par les GPIO du Raspberry Pi
Pour ce guide, il vous faudra Un Raspberry Pi avec Raspbian d'installé (ou autre chose, si vous préférez NetBSD, plan9, FreeBSD... mais si tout n'est
pas exactement pareil il faudra chercher par vous même, moi je n'ai que des Raspbian, et un RaspBMC ), une LED avec une résistance adaptée
(voir le post sur les composants de base, section "LED", sur cette même page). Par exemple une LED rouge, une résistance de 47Ohms, ou une LED
blanche ou bleue sans résistance, des "jumper wire" (voir le même post), et une breadboard (ou pas, ce sera plus pratique avec, mais on peut faire sans).
Au passage, je fais un post assez concis ici, je détaille certains points sur ce billet de mon blog sur l'utilisation d'une LED avec le PI. Vous n'y trouverez rien
de nécessaire qui ne soit ici,mais quelques petites précisions pour aller plus loin.

Je vous ai fait un petit schéma du montage :


On peut faire ce montage avec seulement deux fils, mais j'en ai utilisé 3 de sorte qu'on puisse brancher plusieurs éléments à la masse du Raspberry. En effet, il n'y a qu'une seule
broche de masse, donc il faudra la partager entre tous les dispositifs en ayant besoin. La masse est la broche P1-06, c'est à dire la sixième broche du connecteur P1, en haut à droite. En pratique, c'est la troisième broche de la colonne de droite, en partant du haut. J'ai connecté arbitrairement le + de la LED à la broche GPIO P1-07, qui correspond au GPIO7 du Raspberry Pi, mais vous pouvez utiliser un autre GPIO si vous le souhaitez. De la même manière, vous pouvez ajouter une seconde LED connectée à un autre GPIO par le +, le - à une autre résistance, et la résistance connectée à la masse.

Au passage, voici une table des GPIO du Raspberry Pi par l'auteur de WiringPi.

Notre montage est maintenant fait, nous allons passer à la programmation du circuit.
Pour cela, nous allons utiliser WiringPi, pour faire cela en C. Il suffira donc d'installer cette maginifique librairie, très pratique, puissante, et efficace, qui à pour but d'imiter les fonctionalités offertes par l'environnement de programmation de l'Arduino, mais sur le Pi.

Pour l'installer, rien de plus simple, connectez vous au pi par SSH, telnet, ou simplement lancez un terminal sur le PI lui même, et tapez les commandes suivantes :

sudo apt-get install git-core
git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
cd wiringPi
./build

Une fois la compilation terminée, vous pourrez utiliser WiringPi.

Maintenant, creez un fichier blink.c, contenant le code suivant :

#include <stdio.h>
#include <wiringPi.h>
int main(void)
{
int pin =7;
if(wiringPiSetup()==-1)
{
  return 0;
}
pinMode(pin,OUTPUT);//on indique que le GPIO7 est en mode sortie
while(1)
{
  digitalWrite(pin,1);//la valeur est définie à HIGH (3.3v)
  delay(500); //on attend 500ms
  digitalWrite(pin,0);//la valeur est définie à LOW (0V)
  delay(500);
}
  return 0;
}

Il ne reste plus qu'à compiler. Il faudra rajouter des flags pour qu'il sache qu'il faut utiliser WiringPi :

gcc blink.c -o blink -lwiringPi

On peut alors exécuter le programme :

sudo ./blink

Le sudo permet de l'exécuter comme si on était root, car il faut des droits root pour accéder aux GPIO, à moins de modifier les droits d'accès de ceux ci.
A ce moment, votre LED devrait se mettre à clignoter. Vous pouvez en ajouter d'autres, en définissant les GPIO selon la table des GPIO du Raspberry Pi par l'auteur de WiringPi.
Vous pouvez maintenant changer la vitesse de clignotement, mais aussi faire un programme qui allume la led, et un autre qui l’éteint. Il devient alors possible de lancer ces programmes
depuis d'autres selon des conditions précises, par exemple lorsque l'occupation CPU dépasse un certain seuil, dès que le réseau est détecté, dès que le ping est trop élevé, etc...

Voici le code en python :

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BOARD)
GPIO.setup(7, GPIO.OUT)
while true:
  GPIO.output(7, False)
  time.sleep(0.5)
  GPIO.output(7, True)
  time.sleep(0.5)

il faut l'exécuter avec sudo également :

sudo python blink.py

Voici la dernière version commentée du code source :

• Commander une LED via les GPIO du Raspberry Pi.

Dans le prochain billet, nous verrons comment lire la valeur d'un bouton poussoir, et, par exemple, changer l'état de la LED.

Modifié par sky99, 10/03/2013 - 16:51.

[sky99]

Lire un bouton via les ports GPIO du raspberry
Nous avons vu une interaction "basique" avec le pi par le biais d'une LED. De cette manière, il est possible d'envoyer des données du pi vers le monde extérieur.
Aujourd'hui nous verrons une seconde interaction avec le PI, mais dans l'autre sens : l'utilisateur pourra envoyer une information au Raspberry. Nous allons
lire la valeur d'un bouton poussoir (allumé/eteint) ou d'un interrupteur.

Reprenons le schéma du précédent tutoriel sur le contrôle d'une LED, et ajoutons y un bouton poussoir. Le schéma donnera à peu près ceci :


Nous utilisons un GPIO supplémentaire pour le bouton, et il nous faut une résistance dite "de tirage". Dans ce cas, il s'agit d'une résistance "pull-up", qui fait en sorte que quand le bouton n'est pas préssé, la valeur lue est "high" (1), et quand on appuie, la valeur sera 0. Il est possible de faire le contraire avec une résistance "pull-down". Le résultat sera le même, il faudra seulement penser à inverser les valeurs dans le code. Ici, la résistance doit avoir une valeur élevée, entre 2000 et 10 000 Ohms.

Note importante : le rail d'alimentation doit être connecté au +3.3V et surtout pas au +5V sous peine de dégâts à votre pi!

Voici maintenant le code qui permettra de lire la valeur du bouton :

#include <stdio.h>
#include <wiringPi.h>
int main(void)
{
int switchPin=0;
if(wiringPiSetup()==-1)
	  {return 0;}
//le port GPIO du bouton est configuré en lecture
pinMode(switchPin,INPUT);
int button=0;
while(1)
{
  //on lit la valeur de la broche GPIO
  button=digitalRead(switchPin);
  if(button==0)//Si un appui sur le bouton est détecté
  {
   //on affiche un message
   printf("button pressed!\n");
   //cette boucle permet de gerer un appui continu
   while(button==0)
	{
			//on relit la valeur à chaque fois
			button=digitalRead(switchPin);
			delay(20);//et on attend 20ms
	}
  }
  delay(20);//on attend 20ms entre chaque lecture.
}
  return 0;
}

L’attente de 20ms sert non seulement à ne pas surcharger le CPU, mais également à filtrer le rebond du bouton. Comme il s’agit d’un dispositif imparfait, sans cette attente, nous aurions une successions de changements d’états (0-1-0-1-0-1 …) lors des phases d’appui et de relâchement du bouton. Ce phénomene ne survient pas lorsque le bouton est maintenu enfoncé ou lorsqu’on ne le touche pas, mais uniquement sur les transitions.
La seconde boucle permet de ne considérer qu’un seul appui tant que le bouton est maintenu enfoncé, sinon, nous aurions une succession d’appuis, et un affichage toutes les 20ms tant que le bouton est maintenu enfoncé. Cela peut paraître superflu, mais sans cela, si vous appuyez fugitivement sur le bouton, mais tout de même plus de 20ms, il y aurait au moins deux pressions de comptabilisées.

On compile ensuite le code :

gcc readButton.c -o readButton -lwiringPi

Et on l'exécute :

sudo ./readButton

Il est également possible de combiner ce code avec le précédent :

#include <stdio.h>
#include <wiringPi.h>
int main(void)
{
int switchPin=0;
int ledPin =7;
if(wiringPiSetup()==-1)
		  {return 0;}

//le port GPIO du bouton est configuré en lecture
pinMode(switchPin,INPUT);
//le port GPIO de la LED est configuré en ecriture
pinMode(ledPin,OUTPUT);
int button=0;
int ledState=0;//état initial de la LED
digitalWrite(ledPin,ledState);//on eteint la LED au départ
while(1)
{
  //on lit la valeur de la broche GPIO
  button=digitalRead(switchPin);
  if(button==0)//Si un appui sur le bouton est détecté
  {
   //on affiche un message
   printf("button pressed!\n");
   if(ledState==0)
   {ledState=1;}
   else
	  {ledState=0;}
   digitalWrite(ledPin,ledState);//on applique le nouvel état de la LED
   //cette boucle permet de gerer un appui continu
   while(button==0)
   {
		   //on relit la valeur à chaque fois
		   button=digitalRead(switchPin);
		   delay(20);//et on attend 20ms
   }
  }
  delay(20);//on attend 20ms entre chaque lecture.
}
  return 0;
}

Voici également un code minimal en python pour lire la valeur du bouton :

import time
from RPi import GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(0, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
while True:
	inputval = GPIO.input(0)
	print inputval
	time.sleep(1)

Voici pour aller plus loin un tutoriel en anglais sur le même sujet, avec le schéma de montage pour une résistance pull-up et pour une résistance pull-down.

Si les codes ci dessus ne passent pas par "copier-coller", vous pouvez directement les récupérer sur les liens ci dessous:

• Lire simplement la valeur d'un bouton ;
• Lire la valeur d'un bouton et inverser l'état d'une LED.

Voici la dernière version des codes sources, sur une page de projet (cette version sera à jour si des changements sont requis):

• Lire simplement la valeur d'un bouton poussoir ;

Modifié par sky99, 10/03/2013 - 16:36.

[gnarkk]

Super sujet, ça rapelle un peu les cours d'automatisme (oublié depuis).

En tout cas lecture agréable et instructive. En attente de la suite.

[jeliel]

Super sujet !

[sky99]

Merci de vos commentaires
Surtout n'hésitez pas à poser des questions, demander des tutoriels, des schémas...
Je suis loin de tout maîtriser, mais si j'ai les composants, je serai heureux de chercher comment faire :)
Dans le prochain billet, nous connecterons un convertisseur analogique vers numérique au Raspberry pi pour pouvoir lire des capteurs analogiques
(on commencera par un capteur de température, et un capteur de luminosité. On pourrait voir au passage comment lire un capteur de distance
ultrasonique et un capteur de distance IR, comme ça ce seront des briques du robot que nous aurons vues!)

[sky99]

Comment lire la valeur de capteurs analogiques avec un Raspberry Pi en utilisant une puce MCP3008 (convertisseur analogique vers numérique)
Le MCP 3008 est un ADC, soit un convertisseur analogique vers numérique. Nous avons déjà décrit le MCP3008 dans le post sur les composants utiles, dans la partie sur les puces. Nous allons maintenant voir comment câbler cette puce à un Raspberry Pi, et comment accéder aux données.
Cette puce utilise le bus SPI, qui utilisera 4 GPIO et nous permettra d'interagir avec la puce, en demandant la lecture de l'une des 8 entrées analogiques qu'elle nous offre. Il nous faudra donc:

• Un Raspberry Pi;
• Une breadboard;
• Des Jumper Wire;
• une puce MCP3008
• Un capteur analogique pour tester le tout (un potentiomètre suffira)

La première chose à faire, c'est de déterminer le "haut" de la puce. Le haut est le coté ou il y a un petit creux en forme de demi lune et/ou un petit rond. Assurez vous de bien mettre la puce dans le bon sens, ou ça ne marchera pas. Le haut est représenté par la demi lune sur le schéma.
Il faudra effectuer les branchements comme suit :


Les GPIO "A,B,C et D" sur le schéma ont été notés ainsi car il est possible d'en utiliser d'autres. En pratique, pour cet exemple, nous utiliserons les suivants :

• La broche CLK est la 4eme à droite en partant du haut. Nous la connecterons au GPIO18 du Raspberry Pi. C’est le fil vert sur le schéma;
• La broche Dout est juste en dessous, la 5eme à droite en partant du haut. Connectons la au GPIO23. (fil orange);
• La broche Din est celle du dessous, la 6eme à droite en partant du haut. Elle pourra aller en GPIO24. (fil jaune);
• La broche CD est encore en dessous, la 7eme à droite, en partant du haut. On la connecte au GPIO25. (fil bleu).

Le +3.3V est la broche P1-01 du Raspberry, soit la première en haut à gauche. La masse est la broche P1-06, soit la troisième en partant du haut sur la colonne de droite.

Tous les branchements de droite sont nécessaires au fonctionnement de la puce. Sur le coté gauche de la puce, vous avez les entrées analogiques, de 0 à 7. Nous avons ici branché un potentiomètre, dont nous mesurerons la valeur. En mesurant les valeurs minimales et maximales, on peut transformer la valeur lue en pourcentage par exemple.

Si vous ne pouvez pas voir l'image, j'ai fait une description texte du montage avec de plus amples explications à cette adresse.

Passons maintenant au code. Pour l'instant, je ne sais pas encore utiliser le bus SPI avec wiringPi, donc je vous propose un code tiré de celui de l'exemple/tutoriel d'Adafruit sur le MCP3008, écrit en Python. J'ai modifié le code d'Adafruit pour ne conserver que ce qui est nécessaire :

#!/usr/bin/env python
import time
import os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7
def readadc(adcnum, clockpin, mosipin, misopin, cspin):
		if ((adcnum > 7) or (adcnum < 0)):
				return -1
		GPIO.output(cspin, True)
		GPIO.output(clockpin, False)  # start clock low
		GPIO.output(cspin, False)	 # bring CS low
		commandout = adcnum
		commandout |= 0x18  # start bit + single-ended bit
		commandout <<= 3	# we only need to send 5 bits here
		for i in range(5):
				if (commandout & 0x80):
						GPIO.output(mosipin, True)
				else:
						GPIO.output(mosipin, False)
				commandout <<= 1
				GPIO.output(clockpin, True)
				GPIO.output(clockpin, False)
		adcout = 0
		# read in one empty bit, one null bit and 10 ADC bits
		for i in range(12):
				GPIO.output(clockpin, True)
				GPIO.output(clockpin, False)
				adcout <<= 1
				if (GPIO.input(misopin)):
						adcout |= 0x1
		GPIO.output(cspin, True)
		adcout /= 2	   # first bit is 'null' so drop it
		return adcout
# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisées si vous avez utilisé un autre câblage que celui du tutoriel.
SPICLK = 18
SPIMISO = 23
SPIMOSI = 24
SPICS = 25
# definition de l'interface SPI
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)
#definition du ADC utilise (broche du MCP3008). Cette valeur peut aller de 0 à 7.
adcnum = 0
# Lecture de la valeur brute du capteur
read_adc0 = readadc(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS)
# conversion de la valeur brute lue en milivolts = ADC * ( 3300 / 1024 )
millivolts = read_adc0 * ( 3300.0 / 1024.0)
print "\tvaleur brute : %s" % read_adc0
print "\ttension : %s millivolts" % millivolts

Avec ce code, vous pouvez alors lire la valeur de n'importe laquelle des 8 entrées (et les 8 capteurs peuvent être connectés en même temps)

Quand j'aurai un code en C utilisant WiringPi, je le posterai.

Modifié par sky99, 05/02/2013 - 01:16.

[sky99]

Lire la valeur d'une photo-résistance en utilisant le convertisseur analogique-numérique MCP3008

Nous allons utiliser une photorésistance pour mesurer la luminosité. On peut se servir de ce montage
pour simplement mesurer l'intensité lumineuse ambiante, détecter s'il s'agit du jour ou de la nuit, orienter un dispositif
vers une source de lumière, allumer ou éteindre un dispositif en fonction de la luminosité,
faire un capteur détectant qu'un objet passe dans son "champ de vision", et bien d'autres
applications.

Il nous faudra une photo résistance, ou LDR (Light Dependent Resistor), une résistance entre 2000 et 10 000Ohms,
un Raspberry pi connecté à un MCP3008 (voir le post sur la connexion du MCP3008), et, (c'est facultatif, mais comme toujours
très pratique) une breadboard.

Il suffira d'utiliser le schéma ci dessous :

Le fil jaune allant vers l'une des entrées du MCP3008 -n'oubliez pas de définir correctement l'entrée dans le code si vous changez-, et le rouge
vers le 3.3v (sur le rail de la breadboard ayant le MCP3008), et le noir vers la masse.

Le code sera le même que pour le potentiomètre :

#!/usr/bin/env python
import time
import os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7
def readadc(adcnum, clockpin, mosipin, misopin, cspin):
		    if ((adcnum > 7) or (adcnum < 0)):
						    return -1
		    GPIO.output(cspin, True)
		    GPIO.output(clockpin, False)  # start clock low
		    GPIO.output(cspin, False)    # bring CS low
		    commandout = adcnum
		    commandout |= 0x18  # start bit + single-ended bit
		    commandout <<= 3    # we only need to send 5 bits here
		    for i in range(5):
						    if (commandout & 0x80):
										    GPIO.output(mosipin, True)
						    else:
										    GPIO.output(mosipin, False)
						    commandout <<= 1
						    GPIO.output(clockpin, True)
						    GPIO.output(clockpin, False)
		    adcout = 0
		    # read in one empty bit, one null bit and 10 ADC bits
		    for i in range(12):
						    GPIO.output(clockpin, True)
						    GPIO.output(clockpin, False)
						    adcout <<= 1
						    if (GPIO.input(misopin)):
										    adcout |= 0x1
		    GPIO.output(cspin, True)
		    adcout /= 2    # first bit is 'null' so drop it
		    return adcout
# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisées si vous avez utilisé un autre câblage que celui du tutoriel.
SPICLK = 18
SPIMISO = 23
SPIMOSI = 24
SPICS = 25
# definition de l'interface SPI
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)
#definition du ADC utilise (broche du MCP3008). Cette valeur peut aller de 0 à 7.
adcnum = 0
# Lecture de la valeur brute du capteur
read_adc0 = readadc(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS)
# conversion de la valeur brute lue en milivolts = ADC * ( 3300 / 1024 )
millivolts = read_adc0 * ( 3300.0 / 1024.0)
print "\tLuminosite - valeur brute : %s" % read_adc0
print "\ttension : %s millivolts" % millivolts

La valeur de la résistance permet d'ajuster votre montage à des conditions de faible ou de forte luminosité.
Je chercherai davantage d'informations sur le sujet, et dès que je retrouve le lien, je le posterai ici.

[rob44]

Ceci est juste un post d'encouragement pour continuer le sujet.
On ne trouve pas beaucoup de tutoriels aussi détaillés et ça m'intéresse grandement.

[sky99]

Ceci est juste un post d'encouragement pour continuer le sujet.
On ne trouve pas beaucoup de tutoriels aussi détaillés et ça m'intéresse grandement.

Merci des encouragements, ça fait plaisir de voir que le travail est apprécié :)
Au passage, si vous avez des requêtes de tutos, de montages, d'applications, demandez, je peux toujours
essayer de voir comment bricoler quelque chose si j'ai le matos, et de faire un tuto ensuite :)

[sky99]

Lire la valeur d'un capteur de distance
Aujourd'hui nous verrons comment utiliser deux capteurs de distance de deux technologies :

• Un capteur infrarouge sharp permettant de détecter des objets de 10 à 80cm de distance (le câblage et le code seront identiques avec le capteur sharp IR 20-150cm, et probablement identiques avec pas mal d'autres capteurs IR. Vérifiez les datasheets pour voir le câblage sur des modèles différents);
  
• Un capteur de distance à ultrasons, le Maxbotix LV-EZ4 Le câblage et le code seront les mêmes pour la gammes LV-EZ0 à 4, et HRLV-EZ0 à 4.

Les capteurs infrarouges

Comme vous pouvez le voir, vous avez 3 fils. Le câblage est extrêmement simple :

• Le fil noir est connecté à la masse (connecteur P1-06 du raspberyPi, 3ème en partant du haut, colonne de droite)
• Le fil rouge est connecté au +3.3V (connecteur P1-01 du Raspberry, premier pin, en haut à gauche des GPIO)
• Le fil blanc est connecté à une entrée analogique de votre MCP3008.

A partir de la, vous pouvez lire les valeurs avec un code très simple :

#!/usr/bin/env python
import time
import os
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7
def readadc(adcnum, clockpin, mosipin, misopin, cspin):
		if ((adcnum > 7) or (adcnum < 0)):
				return -1
		GPIO.output(cspin, True)
		GPIO.output(clockpin, False)  # start clock low
		GPIO.output(cspin, False)	 # bring CS low

		commandout = adcnum
		commandout |= 0x18  # start bit + single-ended bit
		commandout <<= 3	# we only need to send 5 bits here
		for i in range(5):
				if (commandout & 0x80):
						GPIO.output(mosipin, True)
				else:  
						GPIO.output(mosipin, False)
				commandout <<= 1
				GPIO.output(clockpin, True)
				GPIO.output(clockpin, False)

		adcout = 0
		# read in one empty bit, one null bit and 10 ADC bits
		for i in range(12):
				GPIO.output(clockpin, True)
				GPIO.output(clockpin, False)
				adcout <<= 1
				if (GPIO.input(misopin)):
						adcout |= 0x1

		GPIO.output(cspin, True)

		adcout /= 2	   # first bit is 'null' so drop it
		return adcout

# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisees.
SPICLK = 18
SPIMISO = 23
SPIMOSI = 24
SPICS = 25

# definition de l'interface SPI
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)

#definition du ADC utilise (broche du MCP3008)
adcnum = 0
while True:
# Lecture de la valeur brute du capteur
read_adc0 = readadc(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS)
# conversion de la valeur brute lue en milivolts = ADC * ( 3300 / 1024 )
millivolts = read_adc0 * ( 3300.0 / 1024.0)
print "valeurs lues : "
print "\tvaleur brute : %s" % read_adc0
print "\ttension : %s millivolts" % millivolts
time.sleep(0.5)

Si vous souhaitez savoir la distance correspondant à la valeur lue, il faudra se référer à la courbe en page 5 des spécifications.
En pratique, on à approximativement les correspondances suivantes :

• 10cm : 2300mV
• 20cm : 1350mV
• 30cm : 900mV
• 40cm : 750mV
• 50cm : 650mV
• 60cm : 500mV
• 70cm : 450mV
• 80cm : 440mV

Quand vous serez en dessous d'une certaine distance à l'objet (moins de 10cm), la valeur lue apparaîtra comme plus grande. Ainsi, en dessous de 10cm, s'approcher d'un objet peut donner l'impression de s'en éloigner. Une solution est de placer le capteur à l'arrière du robot, ou au moins à 10cm du bord de celui ci, de sorte que la distance aux obstacles soit au moins égale à 10cm.

Vous trouverez ici la datasheet de ce capteur sharp IR 10-80cm, pour de plus amples détails.


Au passage, un capteur IR à très courte portée (5 ou 10cm) pourra permettre de détecter le vide devant le robot et éviter de tomber dans des escaliers.

Utilisation d'un capteur de distance à ultrasons
Le principe ici est le même que l'écholocalisation utilisée par les chauves souris : le capteur émet un ping dans les ultrasons et mesure le temps mis par le ping pour revenir. Chez maxbotix, il existe deux grandes séries de capteurs : les EZ-LVx avec x allant de 0 à 4, qui sont les moins chers, et dont la résolution est de 1", soit environ 2.5cm. C'est bien suffisant pour les applications robotiques standard, la détection d'objets, ou dans un véhicule pour détecter les obstacles en cas de marche arrière. La seconde série est la HREZ-LVx, avec toujours x allant de 0 à 4. Cette fois ci la résolution est de 1mm, pour environ 10$ de plus. Le x qui vient derrière les références indique la largeur du faisceau. Plus le chiffre est élevé, plus le faisceau est fin et directionnel. Si votre robot doit détecter de petits objets, le faisceau devra être plus fin, si vous voulez détecter plus facilement de gros objets sans avoir à "viser", un faisceau plus large sera plus adapté. J'ai choisi le EZ-LV4 pour ma part, car le faisceau étroit permet d'envisager de situer précisément la position de l'objet en orientant le capteur, et que de toutes façons, pour un petit robot, la largeur du faisceau sera suffisante pour détecter un objet étant juste devant. En revanche, il risque de ne pas détecter un objet un peu sur le coté, ce qui est une bonne chose, car il passera entre les obstacles.

Quand vous recevrez votre capteur, vous pouvez soit souder des fils, ou des broches. J'ai choisi des broches coudées, et j'en ai soudé une barrette de 5 de façon à pouvoir utiliser toutes les fonctionnalités du capteur. Pour l'instant, je vais décrire la plus simple : la lecture de la distance par le pin analogique.
Sur la photo ci dessus, le trou le plus en haut à gauche est la masse. Vous devez connecter cet élément à la masse du Raspberry pi.
Le second trou en partant de la gauche, en haut, est le VCC, qui sera a 5V sur un Arduino, mais que nous connecterons au +3.3V sur le Raspberry.
Enfin, le 5eme trou en partant de la gauche, en haut, correspond à la broche analogique. Il suffira de connecter cette broche à une broche d'entrée analogique du MCP3008.
A partir de là, la lecture sera très simple, puisque contrairement au capteur infrarouge, l'échelle est linéaire (si vous lisez une valeur qui correspond à 1m, le double de cette valeur correspondra à 2m!)
En pratique, voici un code fonctionnel :

#!/usr/bin/env python
import time
import os
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7
def readadc(adcnum, clockpin, mosipin, misopin, cspin):
		if ((adcnum > 7) or (adcnum < 0)):
				return -1
		GPIO.output(cspin, True)
		GPIO.output(clockpin, False)  # start clock low
		GPIO.output(cspin, False)	 # bring CS low

		commandout = adcnum
		commandout |= 0x18  # start bit + single-ended bit
		commandout <<= 3	# we only need to send 5 bits here
		for i in range(5):
				if (commandout & 0x80):
						GPIO.output(mosipin, True)
				else:  
						GPIO.output(mosipin, False)
				commandout <<= 1
				GPIO.output(clockpin, True)
				GPIO.output(clockpin, False)

		adcout = 0
		# read in one empty bit, one null bit and 10 ADC bits
		for i in range(12):
				GPIO.output(clockpin, True)
				GPIO.output(clockpin, False)
				adcout <<= 1
				if (GPIO.input(misopin)):
						adcout |= 0x1

		GPIO.output(cspin, True)

		adcout /= 2	   # first bit is 'null' so drop it
		return adcout

# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisees.
SPICLK = 18
SPIMISO = 23
SPIMOSI = 24
SPICS = 25

# definition de l'interface SPI
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)

#definition du ADC utilise (broche du MCP3008)
adcnum = 2
inch=3300.0/512.0
while True:
# Lecture de la valeur brute du capteur
read_adc0 = readadc(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS)
# conversion de la valeur brute lue en milivolts = ADC * ( 3300 / 1024 )
millivolts = read_adc0 * ( 3300.0 / 1024.0)

dist0=millivolts/inch
dist1=dist0 * 2.54
print "valeurs lues : "
print "\tvaleur brute : %s" % read_adc0
print "\ttension : %s millivolts" % millivolts
print "\tdistance : %s pouces" % dist0
print "\tdistance : %s cm" % dist1
time.sleep(0.05)

Un pouce de distance vaut VCC/512, soit 3300/512.
Pour obtenir la distance en pouces, ils suffit donc de diviser la tension en millivolts par VCC/512. En pratique, la tension lue est obtenue en multipliant par VCC/1024, car notre ADC travaille sur 10 bits, soit 2^10=1024 valeurs.

Le capteur à une fréquence de rafraîchissement de 20Hz, vous pouvez donc lire 20 valeurs par seconde, le time.sleep(0.05) correspond à une attente de 50ms entre chaque mesure, donc 20 mesures par seconde (20Hz).

Toute valeur en dessous de 6 pouces de distance sera retournée comme 6 pouces. La zone aveugle du capteur est un peu plus importante qu'avec le capteur IR, mais contrairement à celui ci, vous savez quand vous êtes trop proche d'un objet.

Pour plus de détails sur ces capteurs, voici la fiche technique des capteurs Maxbotix :

• LV-EZ0;
• LV-EZ1;
• LV-EZ2;
• LV-EZ3;
• LV-EZ4;
• HRLV-EZx;

Petites précisions supplémentaires sur le choix des capteurs.
Les capteurs infrarouges ont un faisceau très fin, et peuvent donc détecter des objets très fins, mais aussi passer dans une fente et ne pas détecter les objets alentours. Il convient donc de balayer la zone cible avec le capteur pour avoir des résultats fiables. La fréquence élevée de rafraîchissement du capteur (dans les 400Hz) permet de faire de nombreuses mesures et d'utiliser une moyenne. Idéalement, votre capteur IR devrait être accompagné d'un servomoteur pour faire un balayage, ou a défaut plusieurs capteurs IR. En pratique, on peut très bien s'en sortir avec plusieurs capteurs, mais il faut s'attendre à devoir faire quelques ajustements.

Les capteurs ultrasoniques sont plus lents, et ne pourront peut être pas détecter les objets étroits comme des pieds de chaise, mais détectent dans un cône en face du capteur tout objet de taille suffisante. Il n'est donc pas nécessaire de les orienter avec un servomoteur, et ils peuvent donc être fixes. De mon expérience, les valeurs lues sont bien plus stables que pour le capteur IR, ou des valeurs complètement folles apparaissent parfois.

Enfin, l'échelle du capteur ultrasons est linéaire, et les objets trop proches sont quand même détectés. Cela rend son utilisation bien plus facile à mes yeux, et le coût initial d'un tel capteur est certes plus élevé (22-25$ avec une résolution de 1 pouce, 32$ avec une résolution de 1mm), mais celui ci est suffisant "out of the box", ne requiert pas de servomoteurs ou d'ajustements spécifiques. De fait, si on prend un capteur IR a 15$ auquel on ajoute un servomoteur à 5-10$, on arrive à un coût similaire... La portée de 6m permet également au capteur à ultrasons de cartographier les obstacles de loin, et faire des algorithmes de prévision de trajectoire...

Bref, pour commencer, je vous conseillerais le capteur ultrasonique, quitte à rajouter des capteurs de collision physique (ça vaut 1 à 2$ le switch avec levier) en façade du robot pour détecter les collisions avec des objets fins.

Il est bien sur possible de combiner les deux, leurs forces et faiblesses étant complémentaires.

Modifié par sky99, 06/02/2013 - 06:49.

[sky99]

Mesurer des températures avec une sonde de température analogique TMP36
Cette sonde est particulièrement simple à utiliser.

Si vous tenez la sonde comme sur la photo, la patte de gauche devra être connectée au 3.3V du Raspberry, la patte de droite à la masse, et la patte centrale sur l'une des entrées analogique du MCP3008. Pour la suite, le code est élémentaire :

#!/usr/bin/env python
import time
import os
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7
def readadc(adcnum, clockpin, mosipin, misopin, cspin):
	    if ((adcnum > 7) or (adcnum < 0)):
			    return -1
	    GPIO.output(cspin, True)
	    GPIO.output(clockpin, False)  # start clock low
	    GPIO.output(cspin, False)	 # bring CS low

	    commandout = adcnum
	    commandout |= 0x18  # start bit + single-ended bit
	    commandout <<= 3    # we only need to send 5 bits here
	    for i in range(5):
			    if (commandout & 0x80):
					    GPIO.output(mosipin, True)
			    else:  
					    GPIO.output(mosipin, False)
			    commandout <<= 1
			    GPIO.output(clockpin, True)
			    GPIO.output(clockpin, False)

	    adcout = 0
	    # read in one empty bit, one null bit and 10 ADC bits
	    for i in range(12):
			    GPIO.output(clockpin, True)
			    GPIO.output(clockpin, False)
			    adcout <<= 1
			    if (GPIO.input(misopin)):
					    adcout |= 0x1

	    GPIO.output(cspin, True)
 
	    adcout /= 2	   # first bit is 'null' so drop it
	    return adcout

# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisees.
SPICLK = 18
SPIMISO = 23
SPIMOSI = 24
SPICS = 25

# definition de l'interface SPI
GPIO.setup(SPIMOSI, GPIO.OUT)
GPIO.setup(SPIMISO, GPIO.IN)
GPIO.setup(SPICLK, GPIO.OUT)
GPIO.setup(SPICS, GPIO.OUT)

#definition du ADC utilise (broche du MCP3008)
adcnum = 0
while True:
# Lecture de la valeur brute du capteur
read_adc0 = readadc(adcnum, SPICLK, SPIMOSI, SPIMISO, SPICS)
# conversion de la valeur brute lue en milivolts = ADC * ( 3300 / 1024 )
millivolts = read_adc0 * ( 3300.0 / 1024.0)
bias=0;

# 10 mv per degree
temp_C = ((millivolts - 100.0) / 10.0) - 40.0+ bias
# convert celsius to fahrenheit
temp_F = ( temp_C * 9.0 / 5.0 ) + 32

print "valeurs lues : "
print "\tvaleur brute : %s" % read_adc0
print "\ttension : %s millivolts" % millivolts
print "\ttemperature : %s C" % temp_C
print "\ttemperature : %s F" % temp_F
time.sleep(1)