IO Expander pour ESP32, ESP8266 et Arduino : 24 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Souhaitez-vous étendre les E/S de votre ESP32, ESP8266 ou Arduino ? Et avez-vous pensé à la possibilité de 16 nouveaux GPIO pouvant être contrôlés à l'aide du bus I2C ? Et bien aujourd'hui, je vais vous présenter l'expandeur GPIO MCP23016. De plus, je vais vous montrer comment communiquer un microcontrôleur avec le MCP23016. Je parlerai également de la création d'un programme où nous n'utiliserons que 2 broches de ce microcontrôleur pour communiquer avec l'expandeur. Nous les utiliserons pour contrôler les LED et le bouton.

Étape 1: Présentation

Le périphérique MCP23016 fournit 16 bits pour l'extension GPIO à l'aide du bus I2C. Chaque bit peut être configuré individuellement (entrée ou sortie).

Le MCP23016 se compose de plusieurs paramètres 8 bits pour la sélection d'entrée, de sortie et de polarité.

Les extensions offrent une solution simple lorsque les E/S sont nécessaires pour les commutateurs, les capteurs, les boutons et les LED, entre autres exemples.

Étape 2: Caractéristiques

16 broches d'entrée/sortie (16 entrées standard)

Fréquence d'horloge du bus I2C rapide (0-400 kbits/s)

Trois broches d'adresse matérielle permettent d'utiliser jusqu'à huit appareils

Enregistreur de capture de port d'interruption

Registre d'inversion de polarité pour régler la polarité des données du port d'entrée

Compatible avec la plupart des microcontrôleurs

Étape 3: ESP01 peut avoir 128 GPIO

Un exemple qui montre l'ampleur de cette extension est son utilisation avec ESP01, qui peut être connecté à jusqu'à huit extensions avec seulement deux IOS, atteignant 128 GPIO.

Étape 4: MCP23016

Ici, nous avons le schéma de l'expandeur, qui a deux groupes de huit bits. Cela fait un total de 16 ports. En plus d'une broche d'interruption, il possède la broche CLK, qui relie le condensateur et la résistance, qui sont connectés en interne dans un port logique. Il s'agit de former l'horloge, en utilisant l'idée d'un oscillateur à cristal, qui a besoin d'une horloge à 1 MHz. La broche TP est utilisée pour mesurer l'horloge. Les broches A0, A1 et A2 sont des adresses binaires.

Étape 5: HORLOGE

Le MCP23016 utilise donc un circuit RC externe pour déterminer la vitesse de l'horloge interne. Une horloge interne de 1 MHz est requise (généralement) pour que l'appareil fonctionne correctement. L'horloge interne peut être mesurée sur la broche TP. Les valeurs recommandées pour REXT et CEXT sont indiquées ci-dessous.

Étape 6: Adresse

Pour définir l'adresse du MCP23016, nous utilisons ensuite les broches A0, A1 et A2. Laissez-les simplement à HAUT ou BAS pour le changement d'adresse.

L'adresse sera formée comme suit:

Adresse_MCP = 20 + (A0 A1 A2)

Là où A0 A1 A2 peut prendre des valeurs HAUT/BAS, cela forme un nombre binaire de 0 à 7.

Par exemple:

A0> GND, A1> GND, A2> GND (signifie 000, alors 20 + 0 = 20)

Ou sinon, A0> HIGH, A1> GND, A2> HIGH (c'est-à-dire 101, puis 20 + 5 = 25)

Étape 7: Commandes

Vous trouverez ci-dessous un tableau avec les commandes de communication. Utilisons GP0 et GP1, ainsi que IODIR0 et IODIR1.

Étape 8: Catégories:

GP0 / GP1 - Registres de port de données

Il y a deux registres qui donnent accès aux deux ports GPIO.

La lecture du registre fournit l'état des broches sur ce port.

Bit = 1> HAUT Bit = 0> BAS

OLAT0 / OLAT1 - Sortie REGISTRES LACTCH

Il y a deux registres qui donnent accès aux ports de sortie des deux ports.

IPOL0 / IPOL1 - Registres de polarité d'entrée

Ces registres permettent à l'utilisateur de configurer la polarité des données du port d'entrée (GP0 et GP1).

IODIR0 / IODIR1

Il y a deux registres qui contrôlent le mode pin. (Entrée ou Sortie)

Bit = 1> ENTREE Bit = 0> SORTIE

INTCAP0 / INTCAP1 - Registres de capture d'interruption

Ce sont des registres qui contiennent la valeur du port qui a généré l'interruption.

IOCON0 / IOCON1 - Registre de contrôle d'extension d'E / S

Ceci contrôle la fonctionnalité du MCP23016.

Le réglage du bit 0 (IARES> Résolution d'activité d'interruption) contrôle la fréquence d'échantillonnage des broches du port GP.

Bit0 = 0> (par défaut) Le temps de détection d'activité de port maximum est de 32 ms (faible consommation d'énergie)

Bit0 = 1> le temps de détection d'activité maximum sur le port est de 200 usec (consommation d'énergie plus élevée)

Étape 9: Structure de communication

Je montre ici la classe Wire, qui est la communication I2C dans notre noyau Arduino, qui permet également à l'expandeur de fonctionner avec les Arduino Uno et Mega. Cependant, ce dernier dispose déjà de plusieurs OI. On traite ici des adresses de la puce, du contrôle d'accès, qui sont les codes des registres, ainsi que des données.

Étape 10: Programmer

Notre programme consiste à communiquer l'ESP32 avec le MCP23016 pour avoir plus de GPIO à utiliser. Nous aurons alors un bouton et des LED connectés au MCP23016. Nous les contrôlerons tous en utilisant uniquement le bus I2C. Ainsi, seules deux broches ESP32 seront utilisées. Vous pouvez voir le circuit photo ci-dessous dans la vidéo.

Étape 11: ESP01

Ici, je montre le brochage de l'ESP01.

Étape 12: Montage de l'ESP01

Dans cet exemple, nous avons le GPIO0 connecté dans le SDA et le GPIO2 connecté dans le SCL. Nous avons également une carte relais, un buzzer et une LED. Sur l'autre port, en GP1.0, nous avons une LED de plus avec une résistance.

Étape 13: NodeMCU ESP-12E

Ici, nous avons le brochage du NodeMCU ESP-12E.

Étape 14: Montage du NodeMCU ESP-12E

Dans ce cas, la seule différence par rapport au premier exemple est que vous avez connecté D1 et D2 dans le SDA et le SCL, respectivement.

Étape 15: Nœud Wi-FiMCU-32S ESP-WROOM-32

Voici le brochage du WiFi NodeMCU-32S ESP-WROOM-32.

Étape 16: Node de montage Wi-FiMCU-32S ESP-WROOM-32

Cette fois, la principale différence par rapport aux deux autres exemples est le bouton et les trois LED clignotantes. Ici, le SDA est connecté au GPIO19, tandis que le SCL est connecté au GPIO23.

Étape 17: Bibliothèques et variables

Tout d'abord, nous inclurons Wire.h, qui est responsable de la communication i2c, ainsi que de la définition de l'adresse i2c de MCP23016. Je montre plusieurs commandes, même certaines que nous n'utilisons pas dans ce projet.

#include // spécifie l'utilisation de la bibliothèque Wire.h. //endereço I2C do MCP23016 #define MCPAddress 0x20 // COMMANDE BYTE TO REGISTRE RELATION: Tableau: 1-3 de Microchip MCP23016 - DS20090A //ENDEREÇOS DE REGISTRADORES #define GP0 0x00 // DATA PORT REGISTER 0 #define GP1 0x01 // DATA REGISTRE DE PORT 1 #define OLAT0 0x02 // REGISTRE DE VERROUILLAGE DE SORTIE 0 #define OLAT1 0x03 // REGISTRE DE VERROUILLAGE DE SORTIE 1 #define IPOL0 0x04 // REGISTRE DE PORT DE POLARITE D'ENTREE 0 #define IPOL1 0x05 // REGISTRE DE PORT DE POLARITE D'ENTREE 1 #define IODIR0 0x / I/O DIRECTION REGISTER 0 #define IODIR1 0x07 // I/O DIRECTION REGISTER 1 #define INTCAP0 0x08 // INTERRUPTION CAPTURE REGISTER 0 #define INTCAP1 0x09 // INTERRUPTION CAPTURE REGISTER 1 #define IOCON0 0x0A // I/O EXPANDER CONTROL REGISTER 0 #define IOCON1 0x0B // REGISTRE DE CONTROLE D'EXPANSION E/S 1

Étape 18: configuration

Ici, nous avons les fonctions pour initialiser quatre types différents de microcontrôleurs. Nous vérifions également la fréquence, configurons les GPIO et configurons les broches. Dans la boucle, nous vérifions l'état du bouton.

void setup() { Serial.begin(9600); retard(1000); Fil.commence (19, 23); //ESP32 // Wire.begin(D2, D1); //nodemcu ESP8266 // Wire.begin(); //arduino // Wire.begin(0, 2);//ESP-01 Wire.setClock(200000); //fréquence //configura o GPIO0 como OUTPUT (todos os pinos) configurePort(IODIR0, OUTPUT); //configura o GPIO1 como INPUT o GP1.0 e como OUTPUT os outros GP1 configurePort (IODIR1, 0x01); //seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); //seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000000); } void loop() { //vérifier le boitier GP pour la pression de checkButton(GP1); } // fin de boucle

Étape 19: Configurer le port

Dans cette étape, nous configurons le mode des broches GPIO et identifions le mode des ports.

//configura o GPIO (GP0 ou GP1)//como parametro passamos: //port: GP0 ou GP1 //custom: INPUT para todos as portas do GP trabalharem como entrada // OUTPUT para todos as portas do GP trabalharem como saida / / custom um valor de 0-255 indicando o modo das portas (1=INPUT, 0=OUTPUT) // ex: 0x01 ou B00000001 ou 1: indica que apenas o GPX.0 trabalhará como entrada, o restando como saida void configurePort(port uint8_t, uint8_t personnalisé) { if(personnalisé == INPUT) { writeBlockData(port, 0xFF); } else if(custom == OUTPUT) { writeBlockData(port, 0x00); } else { writeBlockData (port, personnalisé); } }

Étape 20: WriteBlockData & CheckButton

Ici, nous envoyons des données au MCP23016 via le bus i2c, vérifions l'état du bouton, et indiquons la prochaine étape en tenant compte de la condition d'être enfoncé ou non.

//envia dados para o MCP23016 através do barramento i2c//cmd: COMANDO (registrador) //data: dados (0-255) void writeBlockData(uint8_t cmd, uint8_t data) { Wire.beginTransmission(MCPAddress); Wire.write(cmd); Wire.write(données); Wire.endTransmission(); retard(10); }

//verifica se o botão foi pressionado//parametro GP: GP0 ou GP1 void checkButton(uint8_t GP) { //faz a leitura do pino 0 no GP fornecido uint8_t btn = readPin(0, GP); //se botão pressionado, seta para HIGH as portas GP0 if(btn) { writeBlockData(GP0, B11111111); } //cas à contrario deixa todas em estado LOW else{ writeBlockData (GP0, B00000000); } }

Étape 21: ReadPin & ValueFromPin

Nous traitons ici de la lecture d'une broche spécifique, et du retour de la valeur du bit à la position souhaitée.

//faz a leitura de um pino específico//pin: pino desejado (0-7) //gp: GP0 ou GP1 //retorno: 0 ou 1 uint8_t readPin(uint8_t pin, uint8_t gp) { uint8_t statusGP = 0; Wire.beginTransmission(MCPAddress); Wire.write(gp); Wire.endTransmission(); Wire.requestFrom(MCPAddress, 1); // ler do chip 1 octet statusGP = Wire.read(); return valueFromPin(pin, statusGP); } //retorna o valor do bit na posição desejada //pin: posição do bit (0-7) //statusGP: valor lido do GP (0-255) uint8_t valueFromPin(uint8_t pin, uint8_t statusGP) { return (statusGP & (0x0001 << broche)) == 0 ? 0: 1; }

Étape 22: Programme ESP8266

À partir de là, nous verrons comment le programme que nous avons utilisé dans ESP-01 et dans le nodeMCU ESP-12E a été créé, ce qui nous permet de comprendre à quel point les différences entre eux sont minimes.

Nous ne modifierons que la ligne du constructeur de communication i2c, qui est la méthode de début de l'objet Wire.

Décommentez simplement la ligne en fonction de la plaque que nous allons compiler.

// Wire.begin(D2, D1); //nodemcu ESP8266// Wire.begin(0, 2); //ESP-01

Installer

Notez que le constructeur est toujours commenté. Par conséquent, décommentez selon votre carte (ESP-01 ou nodeMCU ESP12-E).

void setup() { Serial.begin(9600); retard(1000); // Wire.begin(D2, D1); //nodemcu ESP8266 // Wire.begin (0, 2); //ESP-01 Wire.setClock(200000); //fréquence //configura o GPIO0 como OUTPUT (todos os pinos) configurePort(IODIR0, OUTPUT); //configura o GPIO1 como OUTPUT (todos os pinos) configurePort(IODIR1, OUTPUT); //seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); //seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000001); }

Boucle

Dans la boucle, nous intervertissons les broches toutes les 1 seconde. Ainsi, lorsque la broche 0 de GP0 est activée, les broches de GP1 sont désactivées. Lorsque la broche 0 de GP1 est activée, les broches GP0 sont désactivées.

void loop() { //seta o pino 7 do GP0 como HIGH e os demais LOW writeBlockData (GP0, B10000000); //seta todos os pinos do GPIO1 como LOW writeBlockData (GP1, B00000000); retard(1000); //seta todos os pinos do GPIO0 como LOW writeBlockData (GP0, B00000000); //seta o pino 0 do GP1 como HIGH e os demais como LOW writeBlockData (GP1, B00000001); retard(1000); } // fin de boucle

Étape 23: IMPORTANT

Les variables et la bibliothèque utilisées sont les mêmes que celles du programme que nous avons fait pour ESP32, ainsi que les méthodes configurePort et writeBlockData.

Étape 24: Fichiers

Téléchargez les fichiers:

PDF

INO (ESP8266)

INO (ESP32)