Jump to content
sky99

Raspberry Pi : fabriquons des trucs!

Publications recommandées

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

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 :

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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

Tutoriels électroniques pratiques

Sondes et capteurs

Robotique

Communications

Merci aux contributeurs, pour l'instant, Yaug, titou190, davsarella et Youri_1er :)
Bien sur merci aux lecteurs de vos retours :calin:

Modifié par sky99

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

:eeek2:

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

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

:chinois:

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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

800px-Front_of_Raspberry_Pi.jpg

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 :

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

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

arduinounor3_MED.jpg

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 :

320px-400_points_breadboard.jpg 594px-BreadboardContacts.svg.png

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

200px-Diodos_LED_foto.png

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.

ID856_MED.jpg?1342883114 mcp23008_MED.jpg?1342023679 ID732_MED.jpg?1342023457ID807_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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

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

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.

tmp36pinout.gif?1340740328

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.

cds_MED.jpg

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 : [media]

[/media]

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

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

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 :

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.

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

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 :

[media]

[/media]

Kit robot économique

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

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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.

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

schema1-led.png

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-coregit clone git://git.drogon.net/wiringPicd wiringPigit pull origincd 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 sortiewhile(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 GPIOimport timeGPIO.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 :

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

schema1-ledbouton.png

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 lecturepinMode(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 lecturepinMode(switchPin,INPUT);//le port GPIO de la LED est configuré en ecriturepinMode(ledPin,OUTPUT);int button=0;int ledState=0;//état initial de la LEDdigitalWrite(ledPin,ledState);//on eteint la LED au départwhile(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 timefrom RPi import GPIOGPIO.setmode(GPIO.BOARD)GPIO.setup(0, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)while True:inputval = GPIO.input(0)print inputvaltime.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:

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

Modifié par sky99

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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.

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

mcp3008_003_pot.png

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 pythonimport timeimport osimport RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7def 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 = 18SPIMISO = 23SPIMOSI = 24SPICS = 25# definition de l'interface SPIGPIO.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 capteurread_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_adc0print "\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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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 :

readphotoresistor1.png

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 pythonimport timeimport osimport RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7def 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 = 18SPIMISO = 23SPIMOSI = 24SPICS = 25# definition de l'interface SPIGPIO.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 capteurread_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_adc0print "\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.

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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.

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

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

Ces capteurs retournent une tension qui est fonction de la distance de l'objet. Ils nécessitent un convertisseur analogique-numérique pour pouvoir être utilisés (par exemple le MCP3008). Il existe toutefois des capteurs purement numériques, et nous avons un tutoriel sur le sujet :

Lire la valeur d'un capteur à ultrasons à sortie numérique par Titou190

Les capteurs infrarouges
sharpdist_MED.jpg
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 pythonimport timeimport osimport RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7def readadc(adcnum, clockpin, mosipin, misopin, cspin):if ((adcnum > 7) or (adcnum < 0)):return -1GPIO.output(cspin, True)GPIO.output(clockpin, False) # start clock lowGPIO.output(cspin, False) # bring CS lowcommandout = adcnumcommandout |= 0x18 # start bit + single-ended bitcommandout <<= 3 # we only need to send 5 bits herefor i in range(5):if (commandout & 0x80):GPIO.output(mosipin, True)else:GPIO.output(mosipin, False)commandout <<= 1GPIO.output(clockpin, True)GPIO.output(clockpin, False)adcout = 0# read in one empty bit, one null bit and 10 ADC bitsfor i in range(12):GPIO.output(clockpin, True)GPIO.output(clockpin, False)adcout <<= 1if (GPIO.input(misopin)):adcout |= 0x1GPIO.output(cspin, True)adcout /= 2 # first bit is 'null' so drop itreturn adcout# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisees.SPICLK = 18SPIMISO = 23SPIMOSI = 24SPICS = 25# definition de l'interface SPIGPIO.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 = 0while True:# Lecture de la valeur brute du capteurread_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_adc0print "\ttension : %s millivolts" % millivoltstime.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.
MaxSonar-EZ1_MED.gif
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 pythonimport timeimport osimport RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7def readadc(adcnum, clockpin, mosipin, misopin, cspin):if ((adcnum > 7) or (adcnum < 0)):return -1GPIO.output(cspin, True)GPIO.output(clockpin, False) # start clock lowGPIO.output(cspin, False) # bring CS lowcommandout = adcnumcommandout |= 0x18 # start bit + single-ended bitcommandout <<= 3 # we only need to send 5 bits herefor i in range(5):if (commandout & 0x80):GPIO.output(mosipin, True)else:GPIO.output(mosipin, False)commandout <<= 1GPIO.output(clockpin, True)GPIO.output(clockpin, False)adcout = 0# read in one empty bit, one null bit and 10 ADC bitsfor i in range(12):GPIO.output(clockpin, True)GPIO.output(clockpin, False)adcout <<= 1if (GPIO.input(misopin)):adcout |= 0x1GPIO.output(cspin, True)adcout /= 2 # first bit is 'null' so drop itreturn adcout# ces numeros de pins GPIO doivent etre modifies pour correspondre aux broches utilisees.SPICLK = 18SPIMISO = 23SPIMOSI = 24SPICS = 25# definition de l'interface SPIGPIO.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 = 2inch=3300.0/512.0while True:# Lecture de la valeur brute du capteurread_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/inchdist1=dist0 * 2.54print "valeurs lues : "print "\tvaleur brute : %s" % read_adc0print "\ttension : %s millivolts" % millivoltsprint "\tdistance : %s pouces" % dist0print "\tdistance : %s cm" % dist1time.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 :


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.

N'oubliez pas qu'il existe aussi des capteurs de distance numériques, et des tutos sur le sujet :

Lire la valeur d'un capteur à ultrasons à sortie numérique par Titou190

Ces capteurs reviennent moins cher, et s'appuient sur la mesure du temps de réponse du capteur. Cela à ses avantages et ses inconvénients, visitez le tuto pour plus de détails.

Il ya aussi le tuto de Yaug : Lire un capteur à ultrasons à sortie numérique HC-SR04, avec le code, les tests de précision, une méthode de lissage des mesures, et plein d'autres astuces.

Si vous avez ce genre de capteurs, je vous conseille de lire ces tutos :)

Modifié par sky99

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

Mesurer des températures avec une sonde de température analogique TMP36

Cette sonde est particulièrement simple à utiliser.

tmp36pinout.gif?1340740328

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 pythonimport timeimport osimport RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)#fonction lisant les donnees SPI de la puce MCP3008, parmi 8 entrees, de 0 a 7def 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 = 18SPIMISO = 23SPIMOSI = 24SPICS = 25# definition de l'interface SPIGPIO.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 = 0while True:# Lecture de la valeur brute du capteurread_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 degreetemp_C = ((millivolts - 100.0) / 10.0) - 40.0+ bias# convert celsius to fahrenheittemp_F = ( temp_C * 9.0 / 5.0 ) + 32print "valeurs lues : "print "\tvaleur brute : %s" % read_adc0print "\ttension : %s millivolts" % millivoltsprint "\ttemperature : %s C" % temp_Cprint "\ttemperature : %s F" % temp_Ftime.sleep(1)

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

Commander des moteurs avec une puce L293D

Nous avons vu comment utiliser une puce MCP3008 pour lire des entrées analogiques, puis comment détecter des obstacles avec un capteur infrarouge ou ultrasons.

Si on se place dans un contexte de robotique, nous avons donc mis en place les organes sensoriels du robot. Maintenant, si nous souhaitons

avoir un robot mobile, il faut lui donner des organes moteurs. En pratique, la solution la plus simple, c'est d'utiliser deux moteurs, et un "ball caster",

pour avoir un robot capable de se déplacer.

On utilisera ce qu'on appelle la "conduite différentielle". Pour avancer ou reculer, on fait tourner les deux moteurs dans le même sens. En revanche,

si l'on fait tourner les deux moteurs dans des sens contraires, le robot tournera sur lui même.

Pour cela, il nous faut pouvoir activer ou non les moteurs, mais également choisir leur sens de rotation. Et c'est la qu'intervient la puce L293D,

qui est un double pont en H, et qui permet de faire cela.

En pratique, il y a deux canaux, un par moteur. Pour chaque canal, on aura deux sorties, qui sont connectées au moteur, et trois entrées :

  • La broche "enable", qui permet d'activer/eteindre le moteur, et qui peut être commandée en pwm pour contrôler la vitesse du moteur,
  • Les deux broches "in", qui permettent de définir le sens de rotation du moteur : si la premiere est à 0 et la seconde a 1, le moteur tourne dans un sens, si la premiere est a 1 et la seconde à 0, le moteur tourne dans l'autre sens.

En pratique, cela signifie que nous aurons besoin de 6 GPIO pour commander les moteurs. Toutefois, on peut réduire ce nombre à 5, en utilisant un seul GPIO pour les deux broches "enable", en partant du principe qu'on fera tourner les deux moteurs en même temps, mais pas forcément dans le même sens. On peut vouloir faire tourner uniquement un moteur à la fois, mais ce n'est généralement pas nécéssaire pour un robot à conduite différentielle. Je vais fournir les deux schémas.

La première étape, c'est de connecter l'alimentation électrique. Voici le schéma de base :

powerlayer2.png

Vous constaterez qu'il y a deux circuits d'alimentation différents : le +5V, à droite, qui provient du +5V du Raspberry Pi, et sert à alimenter la puce.

A gauche, on aura +VM, qui sera la source d'alimentation électrique des moteurs. Pourquoi deux sources d'alimentation? Les moteurs peuvent consommer beaucoup de courant. De plus,

leur consommation est irrégulière, et génère beaucoup de bruit. On préfère donc séparer l'alimentation electrique des moteurs de l'alimentation des circuits logiques pour éviter

de perturber leur fonctionnement. D'autre part, la tension demanndée par les moteurs n'est pas nécéssairement le +5V que fournit le PI. Du coup, on peut mettre un nombre

quelconque de batteries AA en série pour avoir la tension souhaitée (de 4 à 36V peuvent être commandés par le L293D), ou toute autre source de courant.

/!\ Important : n'oubliez pas de connecter la masse de votre alimentation moteurs à la masse du raspberry. Sans cela, le comportement des moteurs sera au mieux étrange, sinon complètement incompréhensible. En revanche, ne connectez PAS les +VM et +5V!

On pourra alors connecter le premier moteur (je détaille ici, je ne détaillerai pas forcément autant à chaque fois, mais ça permet de voir de façon plus lisible le schéma):

motor1.png

les GPIO A et B sont des GPIO de votre choix. Le GPIO C devrait idéalement être un GPIO gérant la PWM, mais on peut aussi utiliser un GPIO normal et ne pas gérer la vitesse du moteur, ou encore utiliser de la PWM software...

On peut alors rajouter le second moteur :

motor2a.png

Idem, les GPIO D et E sont des GPIO de votre choix, et F devrait être un PWM mais on peut se servir de n'importe lequel, pour les mêmes raisons que plus haut.

Ici, nous utilisons 6 GPIO, et activons/eteignons les moteurs séparément. On peut cependant baisser à 5 GPIO, en utilisant le même GPIO pour les deux broches "enable":

motor2b.png

D'autre part, si vous souhaitez utiliser la PWM, il faut songer que le Raspberry Pi ne dispose que d'un seul PWM hardware. Donc a moins d'ajouter un contrôleur pwm,

si vous souhaitez commander la vitesse en PWM hardware des moteurs, c'est la seule solution actuelle.

Pour faire avancer le robot, il faudra donc définir les GPIO comme suit :

  • GPIOA=HIGH
  • GPIOB=LOW
  • GPIOD=HIGH
  • GPIOE=LOW
  • GPIOC= HIGH
  • GPIOF= HIGH si vous l'avez utilisé.

Le couple A,B à high,low définit le sens de rotation du moteur 1,

le couple D,E à high,low définit le sens de rotation du moteur 2.

Vérifiez que les deux moteurs tournent dans le bon sens, sinon inversez les deux fils des moteurs.

Les GPIO C et F activent les moteurs. Quelle que soit la valeur des GPIO A,B,D et E, si le C et le F sont à LOW, les moteurs ne tourneront pas.

Donc pour faire reculer le robot, il faudra faire :

  • GPIOA=LOW
  • GPIOB=HIGH
  • GPIOD=LOW
  • GPIOE=HIGH
  • GPIOC= HIGH
  • GPIOF= HIGH si vous l'avez utilisé.

Nous avons simplement ici inversé le sens de rotation des deux moteurs.

Enfin, pour tourner, on mettra les deux moteurs dans des sens différents :

Tourner à gauche :

  • GPIOA=LOW
  • GPIOB=HIGH
  • GPIOD=HIGH
  • GPIOE=LOW
  • GPIOC= HIGH
  • GPIOF= HIGH si vous l'avez utilisé.

Tourner à droite :

  • GPIOA=HIGH
  • GPIOB=LOW
  • GPIOD=LOW
  • GPIOE=HIGH
  • GPIOC= HIGH
  • GPIOF= HIGH si vous l'avez utilisé.

Le tout sera maintenant de déterminer combien de temps vous avancez, combien de temps vous tournez, etc.

cela, c'est l'implémentation du robot. Il faudra également le faire selon les obstacles détectés par le/les capteurs, par exemple, si un objet est détecté à moins de 20cm, le robot peut tourner à gauche de 10° et reprendre sa routine. Ainsi, si l'objet est toujours devant lui, il tournera encore, jusqu'a ne plus le voir, et sinon il avancera.

En pratique, voici un petit code qui permet de tester le fonctionnement des moteurs, en C:

#include <wiringPi.h>#include <stdio.h>int main(void){int enablePin=7;//broche enable du moteur1int m1=0;//entrée 1 du moteur1int m2=2;//entrée 2 du moteur 1if(wiringPiSetup()==-1){ return 0;}	//on définit les GPIO en sortiepinMode(enablePin,OUTPUT);pinMode(m1,OUTPUT);pinMode(m2,OUTPUT);while(1){			//le moteur 1 tourne dans le sens positif digitalWrite(enablePin,1);//activation du moteur : GPIOC=HIGH digitalWrite(m1,1);//GPIOA=HIGH digitalWrite(m2,0);//GPIOB=LOW sleep(1); digitalWrite(enablePin,0);//extinction du moteur sleep(1);			//Le moteur 1 tourne dans l'autre sens digitalWrite(enablePin,1);//activation du moteur digitalWrite(m1,0);//GPIOA=LOW digitalWrite(m2,1);//GPIOB=HIGH sleep(1); digitalWrite(enablePin,0);//extinction du moteur sleep(1);} return 0;}

L'important, c'est de comprendre qu'une fois que vous aurez défini les GPIO comme il faut, les moteurs tourneront(ou resteront eteints) jusqu'à ce que vous changiez la valeur des GPIO.

Donc en gros, au début, le robot pourra activer les moteurs vers l'avant, et regarder toutes les 50ms la distance des obstacles vers l'avant. Si rien n'est détecté en dessous de 20cm, on ne change rien aux GPIO.

En revanche, si un objet est détecté en dessous de 20cm, on arrête les moteurs. A partir de là, à vous de choisir si le robot tourne à gauche, à droite, s'il fait directement un angle droit ou tourne petit à petit...

En pratique, voici ce que donne le code ci dessus :

[media]

[/media]

Si vous voulez de plus amples explications sur la L293D, j'ai fait un billet sur ce sujet ici.

Modifié par sky99

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

Personnelement ce qui m'intéresse c'est surtout les branchements entre les composants et le rasp.

La partie info ça va, mais pour la partie électro je suis vraiment mauvais.

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

Topic super INtéressant :incline:

J'avais une idée pour l'utilisation d'un RPi, mais je sais pas si c'est faisable... J'ai vu que des cartes additionnelles permettaient de gérer le NFC (compatible Arduino / RPi), mais... Peut-on brancher plusieurs antennes, et déterminer d'où vient le signal ? Ca pourrait être bien cool pour faire de la domotique !

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

Topic super INtéressant :incline:

J'avais une idée pour l'utilisation d'un RPi, mais je sais pas si c'est faisable... J'ai vu que des cartes additionnelles permettaient de gérer le NFC (compatible Arduino / RPi), mais... Peut-on brancher plusieurs antennes, et déterminer d'où vient le signal ? Ca pourrait être bien cool pour faire de la domotique !

Merci :)

Le NFC est fait pour être réellement proche. Donc j'ignore si c'est réellement adapté en utilisant des équipements NFC standard. En revanche, si on part du principe que le NFC c'est une émission électromagnétique classique, sur une fréquence de 13.56Mhz (de tête, donc à vérifier, il existe aussi une norme a 125Khz, mais elle semble moins courante), on peut tout à fait imaginer soit de multiples antennes pour trianguler le signal, soit une tourelle orientable qui pourrait, en utilisant une antenne directionnelle, déterminer l'orientation de l’émetteur NFC.

En revanche, pour trouver un tag NFC, ça risque de ne pas être si simple, car le tag, étant passif, ré-émet en utilisant le courant induit par le champ électromagnétique de l’émetteur, donc il doit capter un rayonnement assez important dans un premier temps, et d'autre part, en émettant, plus on est loin, plus il sera dur de re-capter.

Ceci dit avec une antenne directionnelle, et peut être en augmentant la puissance, on doit pouvoir booster la portée...

Une solution serait d'essayer les antennes home made de type cantena, ou le concept de la passoire métallique qui sert de parabole...

C'est dans l'un de mes projets d'utiliser un Raspberry pi pour détecter physiquement un dispositif wifi; je vous tiendrai informés des résultats :)

Par contre si c'est pour des applications de domotique classique, il y a peut être des solutions plus simples, comme des émetteurs radio classiques, à quoi penses tu comme application domotique?

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

En fait... Je pensais à un truc vachement plus simple : avoir un petit tag sur un bracelet (montre, bijou...), et des lecteurs NFC à la place (ou à côté) des interrupteurs : le RPi récupère le tag NFC du bracelet, identifie de quelle pièce cela provient, et effectue les actions correspondantes.

Cela pourrait donner en substance :

- Personne n°1, salle de bains : chauffage à 26°, lumière à 80%, musique avec telle playlist en shuffle.

- Personne n°3, entrée : chauffage +1°, ouverture des volets dans toutes les pièces, allumage du PC et de la musique dans le salon.

Pour cela, il faudrait pouvoir gérer les différents tags et surtout les différentes provenances... Et ensuite avoir assez d'E/S pour pouvoir gérer toute la maison :transpi:

Mais je pense que ça pourrait être tip top :p

Partager cette publication


Lien vers la publication
Partager sur d'autres sites

Veuillez vous connecter pour commenter

Vous serez en mesure de laisser un commentaire après vous être connecté



Se connecter dès maintenant

×
×
  • Créer...