Ajout de ports d’entrées sorties

1.1        Microchip MCP23S17 et MCP23017

1.1.1        La théorie

Même si le Raspberry possède 26 ports GPIO, il peut être utile dans certain cas d’ajouter des ports d’entrées/sorties supplémentaires.

Pour cela, il y a plusieurs solutions, mais l’une des plus adaptée consiste à interfacer des circuits Microchip MCP23S17 ou MCP23017. Ces circuits ajoutent 16 ports, sont interfacés en SPI pour le MCP23S17 et en I2C pour le MCP23017. Grace à un système intégré dans chaque circuit, il est possible de mettre 8 circuits sur une interface SPI ou I2C. Le Raspberry possédant deux interfaces SPI et une I2C, il est donc possible d’ajouter 3 * 8 * 16 soit pas moins de 384 ports supplémentaires.

1.1.2        L’électronique

Pour étudier les circuits Microchip, nous allons faire un montage comprenant un MCP23017 et deux MCP23S17. Chaque circuit pilotera un afficheur sept segments et aura huit interrupteurs en entrée.

L’alimentation sera en 3.3V, mais vue le nombre de circuit et de LED, il est hors de question de tirer sur l’alimentation du Raspberry. Il faudra impérativement une alimentation externe. L’un des MCP23S17 sera interfacé avec un 74LS244 qui sera alimenté en 5V afin d’effectuer une augmentation de la tension de sorti. Cette augmentation permettra par exemple de piloter des circuits TTL, mais dans notre cas, cela alimentera toujours un afficheur sept segments.

Les résistances des LED sont calculées pour un courant d’environ 5mA. Ce courant est un peu faible pour un afficheur MAN74A, mais cela évite de surcharger les circuits.

Attention car un circuit MCP23017 ou MCP23S17 ne doit pas dépasser 125mA au total et 25mA sur une broche.


 


Le schéma global sera le suivant :


Attention :

Donc, je le rappel il est très important de mettre une alimentation 3.3V externe et de ne pas tirer sur celle du Raspberry.

Le circuit 74LS244 doit être alimenté en 5V, cette tension peut venir du Raspberry ou d’une alimentation externe.

Pour le fonctionnement, il est impératif de relier toutes les masses des alimentations, du Raspberry et des circuits. Surtout pas de masse flottante.


 

Quelques photos du montage :

 


 

1.1.3        Configuration de l’interface I2C

Comme pour le SPI, l’I2C est bloqué par défaut. Afin de communiquer avec le MCP23017, il faut donc activer cette interface.

Pour faire ça, on démarre l’outil de configuration du Raspberry : sudo raspi-config

On sélectionne l’option 7 Advanced Options


 

Puis l’option A7 I2C

Puis on valide l’activation de l’interface


 

Et on a un message qui nous indique que l’interface est active

On valide et on appuis sur « Echap » pour sortir de l’outil.

Si comme moi, vous utilisez PUTTY, vous aurez des messages d’erreur de ce genre :PuTTY X11 proxy: unable to connect to forwarded X server: Network error: Connection refused, mais rien de grave.

Si tout s’est bien passé et il n’y a aucune raison qu’il en soit autrement, vous devez avoir un device qui se nomme i2c-1

On va ensuite s’installer des outils pour l’I2C

Cela permettra de détecter si notre MCP23017 est bien reconnu.

Par défaut, si rien n’est branché, l’interface I2C ne détecte rien

Par contre si le MCP23017 est branché, on a une valeur entre 20h et 27h (c’est bien de l’hexadécimal) dans notre tableau. La valeur variera en fonction de l’adresse qu’on aura assignée à notre circuit via les broches A0, A1 et A2.

Ça prouve que l’I2C détecte bien notre circuit et qu’on va pouvoir discuter avec lui.


 

1.1.4        Le logiciel

Le circuit MCP23S17 est programmable grâce à trois octets.

·         Le premier octet indique l’adresse du composant (un parmi huit) et si la commande est en lecture ou en écriture.

·         Le deuxième octet indique le registre interne que l’on va utiliser

·         Le troisième octet donne la valeur à écrire, ou sera chargé avec la valeur à lire.

Le circuit MCP23017 est également programmable grâce à ces même trois octets, mais la librairie WiringPi masque cette complexité et on a juste à envoyer une valeur dans un registre.

Les registres internes sont :

·         IODIRA : direction du port A (chaque bit peut être en entré ou en sortie)

·         IODIRB : direction du port B

·         IPOLA : polarité du port A (état directe ou inversion de l’état du port)

·         IPOLB : polarité du port B

·         GPINTENA : interruption sur les bits du port A

·         GPINTENB : interruption sur les bits du port B

·         DEFVALA : valeur de comparaison pour une interruption du port A

·         DEFVALB : valeur de comparaison pour une interruption du port B

·         INTCONA : paramétrage de la comparaison pour une interruption du port A

·         INTCONB : paramétrage de la comparaison pour une interruption du port B

·         IOCON : registre de configuration divers

·         GPPUA : active ou désactive les résistances de pull-up du port A

·         GPPUB : active ou désactive les résistances de pull-up du port B

·         INTFA : lecture des conditions d’interruption du port A

·         INTFB : lecture des conditions d’interruption du port B

·         INTCAPA : état du port A lors d’une interruption du port A

·         INTCAPB : état du port B lors d’une interruption du port B

·         GPIOA : Lecture ou écriture du port A

·         GPIOB : Lecture ou écriture du port B

·         OLATA : Lecture des bascules mémoires juste avant les entrées-sorties du port A

·         OLATB : Lecture des bascules mémoires juste avant les entrées-sorties du port B

Si vous voulez toutes les informations sur ces circuits, les datasheets sont disponible chez le constructeur Microchip.

On va donc écrire une librairie C++ pour la gestion des circuits Microchip ainsi qu’une autre pour la gestion des afficheurs MAN74A.

En fait, pour les circuits Microchip, on va écrire trois librairies. Une librairie noyau qui ne sera pas utilisable seule et qui aura toutes les commandes communes aux deux circuits. Puis une avec les spécificités du MCP23S17 et une autre avec les spécificités du MCP23017. Ces deux dernières seront celles qui seront réellement utilisables, elles seront des extensions de la première.

On va donc utiliser dans ce cas des fonctionnalités de la programmation objet.

-          Une librairie virtuelle

-          Deux librairies qui seront des extensions de la librairie virtuelle

On va ensuite écrire quelques logiciels de test qui utiliseront ces librairies.


 

1.1.5        Le fonctionnement

On va se retrouver ici avec beaucoup de fichiers, je vais expliquer à quoi ils servent.

Nom du fichier

Utilité

GestionSPI.h

Quelques déclarations pour le SPI (canaux et fréquence)

GestionMCP23x17.h

L’entête de la librairie commune aux deux circuits Microchip

GestionMCP23x17.cpp

La librairie commune, contenant toutes les fonctions communes

GestionMCP23S17.h

L’entête de la librairie spécifique au MCP23S17

GestionMCP23S17.cpp

La librairie spécifique au MCP23S17

GestionMCP23017.h

L’entête de la librairie spécifique au MCP23017

GestionMCP23017.cpp

La librairie spécifique au MCP23017

GestionMAN74A.h

Macro de fonctionnement des afficheurs

tstMCP23S17.cpp

Test d’un MCP23S17

tstMCP23017.cpp

Test du MCP23017

tst2MCP23S17.cpp

Test des deux MCP23S17

tstMCP23S17intr.cpp

Test d’interruption d’un MCP23S17

tstMCP23S17_2.cpp

Test du deuxième MCP23S17

 

Les commandes de compilation.

Pour compiler mettre tous les fichiers dans un même répertoire, se positionner dessus et lancer les commandes suivantes.

Programme

Compilation

tstMCP23S17.cpp

g++ -o tstMCP23S17 tstMCP23S17.cpp GestionMCP23S17.cpp GestionMCP23x17.cpp –l wiringPi

tstMCP23017.cpp

g++ -o tstMCP23017 tstMCP23017.cpp GestionMCP23017.cpp GestionMCP23x17.cpp –l wiringPi

tst2MCP23S17.cpp

g++ -o tst2MCP23S17 tst2MCP23S17.cpp GestionMCP23S17.cpp GestionMCP23x17.cpp –l wiringPi

tstMCP23S17intr.cpp

g++ -o tstMCP23S17intr tstMCP23S17intr.cpp GestionMCP23S17.cpp GestionMCP23x17.cpp –l wiringPi

tstMCP23S17_2.cpp

g++ -o tstMCP23S17_2 tstMCP23S17_2.cpp GestionMCP23S17.cpp GestionMCP23x17.cpp –l wiringPi

 


 

Quelques explications sur le fonctionnement des tests

Programme

Explication

tstMCP23S17.cpp

Ce programme va faire les actions suivantes :

-          Paramétrer le circuit qui est à l’adresse 0 (celui dont les broches A0, A1 et A2 sont à la masse)

-          Activer les résistances de pull up du port B afin de lire un 1 si les interrupteurs sont ouverts

-          Lire et afficher l’état des interrupteurs câblés sur le port B

-          Allumer l’un après l’autre les segments de l’afficheur

-          Afficher les valeurs de 0 à F (hexa) sur l’afficheur, d’abord sans le point, puis avec

-          Faire une boucle infinie qui affichera le nombre d’interrupteurs enclenchés

-          Faire CTRL-C pour terminer le programme

tstMCP23017.cpp

Ce programme va faire la même chose que le précédent pour le MCP23017. Il prend le circuit qui est à l’adresse 0x20, soit celui dont les broches A0, A1 et A2 sont à la masse

tst2MCP23S17.cpp

Ce programme va lire les valeurs des interrupteurs des deux circuits MCP23S17. Dans ce programme, l’instruction positionnant le flag HaEn est extrêmement importante car sinon, les deux circuits fonctionnent ensemble et les résultats sont mélangés entre les deux circuits (faite l’expérience, enlevez les instructions et vous verrez)

tstMCP23S17intr.cpp

Pour ce programme, bien lire les instructions à l’écran afin de comprendre le fonctionnement des sorties d’interruption (ouvrir tous les interrupteur avant de lancer le programme)

tstMCP23S17_2.cpp

Identique au programme tstMCP23S17.cpp mais pour le circuit à l’adresse 1

 


 

1.1.6        Liste des programmes

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMCP23017.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMCP23017.h

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMCP23S17.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMCP23S17.h

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMCP23x17.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMCP23x17.h

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionSPI.h

https://github.com/montotof123/raspberry/blob/master/070_IO/tst2MCP23S17.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/tstMCP23017.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/tstMCP23S17.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/tstMCP23S17_2.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/tstMCP23S17intr.cpp

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Lien vers la base du site.

1.2        Texas Instrument 74HCT595

1.2.1   La théorie

Ce circuit est un convertisseur série parallèle. Il reprend les mêmes concepts que les circuits précédents, mais de manières plus manuelles. En effet, ici plus question de SPI ou d’I2C, la communication série sera gérée par trois broches GPIO standards. Les trois broches gèreront les données, l’horloge et le verrouillage.

1.2.2        L’électronique

Je vais faire ici deux circuits, l’un gérant un simple afficheur à LED et un deuxième faisant fonctionner une matrice de LED.

Il y a une chose très importante à connaitre avec le 74HCT595, c’est qu’il ne faut pas dépasser 35mA sur une sortie et 70mA sur la totalité des sorties. On trouve souvent sur internet des schémas sans aucune explication qui pourrait faire consommer au moins 20mA sur chaque sortie soit 160mA au total ce qui est beaucoup trop. Ces schémas sont utilisables à condition d’utiliser la technique du multiplexage, c’est-à-dire de n’utiliser qu’une sortie à la fois, mais très rapidement afin de faire croire que toutes les sorties sont utilisées en même temps. Cette technique est très utilisée dans les afficheurs afin de faire croire à l’œil que toutes les LED fonctionnent en même temps. Elle est toutefois très consommatrice en temps machine si elle est faite par programmation.

Cette consommation maximum de 70mA impose d’utiliser des résistances permettant de ne consommer qu’environ 8mA par sortie, ce qui fera 64mA si toutes les sorties fonctionnent. Si ce courant est trop faible, il faudra envisager l’utilisation de buffer type ULN2003 ou de simple transistor, mais cela complexifie l’électronique.

Je vais utiliser ici une technique beaucoup plus simple qui consiste à ne pas dépasser la consommation maximum, mais au prix d’une baisse de luminosité. Les résistances de 330Ω permettent d’avoir une consommation d’environ 10mA. Toutefois ce courant se répartira sur les LED allumées. Donc plus on allume de LED, moins elles sont lumineuses car elles ont de moins en moins de courant. Pour la matrice, il faut utiliser le multiplexage, ce qui fait que seule une rangée sera affichée à la fois, donc 10mA maximum.

Voici les datasheet pour la matrice de LED , l’afficheur et le 74HCT595


 


Premier montage avec l’afficheur


Deuxième montage avec la matrice de LED

 

 


1.2.3        Le logiciel

A la différence de ce qui se fait sur internet, je vais créer des librairies qui permettront de gérer le 74HCT595 et la matrice de LED. Cela permettra de réutiliser facilement ces circuits dans d’autres montages.

Nom du fichier

Utilité

Gestion74HCT595.h

L’entête de la librairie de gestion du 74HCT595

Gestion74HCT595.cpp

Librairie de gestion du 74HCT595. Elle permet d’envoyer un bit ou un octet sur les broches de sortie du circuit. Elle gère également les fonctionnalités d’horloge et de verrouillage des données.

GestionMatriceLedRed8x8.h

Librairie de stockage des différents caractères et symboles pouvant être affichés sur la matrice de LED

GestionPin.h 

L’entête de la classe de base de gestion des GPIO

GestionPin.cpp

La  classe de base de gestion des GPIO

GestionPinGPIO.h 

L’entête de la classe de gestion des GPIO

GestionPinGPIO.cpp

La classe de gestion des GPIO

Makefile

Le fichier permettant de compiler le programme grâce à la commande make

Affichage7seg.cpp

Test qui permet d’allumer les LED de l’afficheur 7 segments en fonction des valeurs envoyées.

AffichageMatrix.cpp

Test qui permet d’afficher des points, des symboles et des caractères sur la matrice de LED. Il comporte une fonction pour afficher facilement sur toute la matrice grâce au multiplexage.

 

Compilation par un simple make qui exécutera les instructions du Makefile


 

Et l’exécution des programmes de test

P1100959


 

1.2.4        Liste des programmes

https://github.com/montotof123/raspberry/blob/master/070_IO/Affichage7seg.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/AffichageMatrix.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/Gestion74HCT595.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/Gestion74HCT595.h

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionMatriceLedRed8x8.h

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionPin.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionPin.h

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionPinGPIO.cpp

https://github.com/montotof123/raspberry/blob/master/070_IO/GestionPinGPIO.h

https://github.com/montotof123/raspberry/blob/master/070_IO/Makefile

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Lien vers la base du site.