Puce MCP23017
Si le nombre de GPIO disponibles sur le Raspberry Pi ne vous convient pas, pas d’inquiétude, il est possible d’en rajouter. La puce MCP23017 permet d’ajouter 16 GPIO , et la puce MCP23008 permet d’en rajouter 8. Dans les deux cas, ces puces se connectent au Raspberry Pi sur des GPIO “spéciaux”, dédiés au protocole I²C. Ce qui est formidable, c’est que même ainsi, vos broches I²C restent disponibles, grâce à un système d’adressage.
Il est ainsi possible de connecter d’autres puces sur les broches I²C en chaînant celles ci avec notre MCP23017 ou MCP23008. Pour cela, on utilisera un système d’adressage que nous verrons plus tard.
Ces deux puces coûtent 2$ pour le MCP23008, et 3$ pour le MCP23017. A moins d’avoir des contraintes d’espace (le MCP23008 se présente sous forme d’une puce à 16 broches, en 2*8, alors que la MCP23017 est une puce à 28 broches, en 2*14) sur votre montage, autant prendre des MCP23017. 🙂
Pour être complet, voici les spécifications des puces :
A noter que la lecture des spécifications n’est pas du tout nécessaire pour l’utilisation de cette puce, je mettrai tout le nécessaire dans ce tutoriel. Toutefois, il peut être utile d’avoir ces fichiers sous la main, par exemple pour les schémas de la disposition des broches de la puce, ou pour y dénicher plus d’informations…
Le câblage des deux puces ne sera pas identique, mais il est assez facile de passer de l’un à l’autre. Pour la suite, je montrerai le câblage des MCP23017 dans un premier temps, et des MCP23008 dans une mise à jour ultérieure. En revanche, le code et tout le reste seront similaires.
Un point intéressant à noter est que ces puces ont de nombreuses fonctionnalités, comme des résistances “pull-up”, qui nous simplifieront la vie pour lire des boutons poussoir, par exemple! En outre, chaque GPIO de la puce peut fournir 25mA, contre 16mA pour les GPIO du Raspberry, ce qui ne suffit pas pour alimenter
pleinement une DEL par exemple (20mA pour les DEL standard), sans compter que le Raspberry ne peut fournir plus de 50mA sur le total des GPIO!
Ici, nous pourrons donc alimenter pleinement 16 LED sans problème. Enfin, un dernier point intéressant, c’est que ces puces sont solides. Je ne vous garantis pas qu’elles sont protégées contre les mauvaises manipulations, je n’ai pas fouillé dans les spécifications pour vérifier. Mais en pratique, sur les miennes,
j’ai fait plein de bêtises, en ayant câblé des choses à l’envers, mis le +3.3V d’alimentation sur une mauvaise broche, au point d’avoir eu deux puces brûlantes.
Eh bien une fois le bon câblage fait, les puces se sont mises à fonctionner comme si de rien n’était…
Utiliser ces puces peut s’avérer intéressant même si vous n’avez pas besoin de plus de GPIO, ne serait-ce que pour protéger le Raspberry pi, car les GPIO “natifs” sont eux très fragiles, et n’ont aucune protection. On peut facilement griller des GPIO ou même un Pi entier en faisant de mauvais branchements…
Dans tous les cas, en cas de mauvaise manipulation au pire, vous grillez une puce qui coûte 3$, et qu’il suffit de changer pour continuer à utiliser votre système…
Le câblage
Passons maintenant à la pratique. Dans un premier temps, je tiens à signaler que je n’ai pas fait ce tutoriel en partant du néant, j’ai utilisé le tutoriel d’Adafruit sur l’utilisation du MCP23017 pour câbler ma première puce. Maintenant j’écris ce tutoriel en essayant d’ajouter ce qui m’a manqué dans celui d’Adafruit.
Voici le schéma du câblage :
Le MCP23017 est alimenté par du 3.3V, qui se connecte à la 6ème broche en partant du bas, à gauche. La masse du Raspberry sera connecté à la 5ème broche en partant du bas, à gauche.
Le GPIO SDA (second en en partant du haut, colonne de gauche sur le Pi) se connecte à la seconde broche en partant du bas, à gauche, du MCP23017. Enfin,le GPIO SCL (troisième broche en partant du haut, colonne de gauche sur le Pi) se connecte à la 3ème broche en partant du bas, à gauche sur le MCP23017.
Sur la colonne de droite du MCP23017, vous constaterez que la 4eme broche en partant du bas est connectée au +3.3V. Cette broche est la broche NON-Reset. Elle est à 3.3V, soit un 1 logique, ce qui veut dire que reset est à 0. Si vous souhaitez faire un reset du MCP23017, vous pouvez toujours connecter cette broche à un GPIO, mais pensez à définir la valeur à 1 pour le fonctionnement normal.
Les trois broches du bas, dans la colonne de droite du MCP23017 servent à coder l’adresse de la puce, sur 3 bits, donc 8 adresses possibles.
Si la broche donnée est sur le +3.3V, alors le bit concerné est à 1. Si la broche est sur le 0V, alors le bit concerné est à 0. Ici, l’adresse est donc 000. Le premier bit de l’adresse est celui tout en bas à droite, le second est le deuxième en partant du bas, à droite, et le troisième bit d’adresse est le troisième en partant du bas, à droite.
Si vous branchez une autre puce I2C, il faudra qu’elle aie une autre adresse. Si ce n’est pas possible pour l’autre puce (adresse soudée par exemple) il est toujours possible de changer celle du MCP23017 ou du MCP23008. Si vous utilisez plusieurs MCP23017 ou MCP23008, il faudra s’assurer d’avoir des adresses différentes pour chaque puce.
Maintenant, vous disposez d’une puce utilisable, et les 8 broches du haut, à gauche comme à droite, sont les GPIO. On peut voir sur ces schémas l’ordre des GPIO, et ou se trouve le premier :
Pinout du MCP230017
Le MCP23008 :
pinout du MCP23008
En premier le MCP23017, ensuite le MCP23008.
Sur le MCP23017, la broche 0 est donc la 7ème en partant du bas. Les numéros de GPIO vont croissant jusqu’au haut de la puce, (en haut à droite c’est la broche 7), et décroissent sur les 8 premières broches de la colonne de gauche (tout en haut à gauche, c’est le GPIO 8, et la 8eme broche en partant du haut sur la colonne de gauche est le GPIO 15).
Dans un prochain billet, nous verrons comment configurer Raspbian pour utiliser le bus I2C.
En attenant, quand vous avez fait cette connexion entre la puce et le Pi, vous disposez de nouveaux GPIO, que l’on utilisera comme les anciens. Par exemple pour commander une LED, le câblage serait le suivant :
La suite au prochain tutoriel!
Merci pour ce tuto.
A t’il une suite ?
Configuration I2C sur raspbian, lecture / écriture sur les gpio du MCP230xx ?
Bonjour, j’ai écrit le tuto complêt sur ce forum :
http://forum.nextinpact.com/topic/165594-raspberry-pi-fabriquons-des-trucs/page-2#entry2749081
Tous les tutos sont également présents ici :
http://forum.pcinpact.com/topic/165594-raspberry-pi-fabriquons-des-trucs/
Bonjour,
Merci pour ce tuto…
J’utilise le GPIO du raspberry en PHP.
Cette fonction permet d’envoyer une impulsion d’une seconde sur la broche $port du GPIO.
function impulsion ($port){
system(“gpio mode “.$port.” out”);
system(“gpio write “.$port.” 1″);
sleep (1);
system(“gpio write “.$port.” 0″);
}
J’aimerai pouvoir utiliser deux 23017 pour avoir 32 IO de disponible.
Comment utiliser l’i2c et les 23017 en PHP avec une fonction similaire ?
Merci
Bonjour Delmas,
le plus simple à mon sens est de faire des scripts python, et de les stocker quelquepart sur le système, avec les droits en exécution pour le serveur web (voir chmod pour cela).
Par la suite, il suffit alors d’utiliser les commandes exec() de php, qui permettent d’exécuter une commande sur le système.
voir la commande exec :
http://php.net/manual/fr/function.exec.php
Une autre solution consiste à creer le script, puis creer un alias vers cette commande (ou l’ajouter au path de l’utilisateur exécutant le serveur web et php), et d’utiliser la fonction shell_exec() de php :
http://php.net/manual/fr/function.shell-exec.php
En effet, il y a peu de chances de trouver une bibliothèque en php pour gérer le MCP23017 directement, et l’écrire serait long. Du coup la solution la plus évidente consiste à faire des appels au système via ces commandes.
Avec les bons scripts, on peut même aller plus loin, et par exemple lancer un clignottement, ce qu’on ne peut pas faire avec php sur un serveur web par défaut. En effet, le script php s’exécute, puis rend la main, et on ne peut pas avoir de boucle infinie sous peine de timeout. En exécutant un script shell, qui quand à lui lancera une commande en différé (par exemple avec at), et celle ci pourra s’exécuter alors même que le script php s’est arrêté depuis longtemps.
Enfin, une autre solution serait de créer tous les scripts requis, puis de créer un service gérant les appels GPIO qu’on pourrait démarer via service start, de façon classique, et avec des options telles que service gpio X state ou on définirait l’état d’un GPIO.
Bref, diverses solutions existent, en conservant php comme interface avec l’utilisateur, mais en exploitant la puissance du bash pour pouvoir faire ce qui est nécéssaire mais complexe via php par un simple appel à des scripts 🙂
Bonjour,
J’ai le projet d’enregistrer la température de 9 capteurs de température (TSYS01) en continu. Le projet en est au niveau conceptuel (j’ai déjà les capteurs) et avant de passer à la pratique, je m’informe. Les capteurs ont bien sûr tous la même adresse I2C. J’envisage donc d’utiliser un MCP23017 pour accéder à chaque capteur. Par contre au niveau câblage, je suis bloqué et tous les tuto sur le net parle d’allumer des leds.
Chaque capteur a 4 pins : Vcc, GND, SCL et SDA.
Pour Vcc et GND, ok.
Par contre pour SCL et SDA : je pensais connecter tous les pins SCL ensemble et chaque pin SDA sur un GPIO du MCP23017.
Qu’en pensez-vous ?
Merci
Bonjour, des images manquent 😉