WT32-ETH01

Dans l'ordre d'apparition, les premières cartes étaient les ESP01 (512Ko) de couleur bleue. Ensuite les ESP01 (512Ko) de couleur noire. Puis les ESP01S (1Mo et 4Mo) de couleur noire. Toutes ces cartes ont en commun les broches de sorties.

Sur la fig.1 on peut voir du haut vers le bas : un ESP01, un ESP01S et un adatpateur permettant de placer les cartes ESP01 sur un breadboard (planche à pain).

Données techniques selon le fabricant

Tension de fonctionnement : 3,0V à 3,6V
Consommation de courant : 80mA à 170mA ; courant de pointe jusqu'à 320mA ; DeepSleep 0,1mA
Consommation de courant maximale par broche : 12 mA
Interfaces : Serial/UART, SDIO, SPI
Réseau : WiFi 802.11 b/g/n 2,4 GHz avec WPA/WPA2 PSK
Température de fonctionnement : -40°C à +125°C
Fréquences d'horloge : 80MHz, 160MHz
SRAM: < 36kB
Mémoire flash : 512 Ko à 1 Mo (selon le modèle)
Broches d'E/S numériques : 2 (GPIO0 et GPIO2)
Pins analogiques : aucune
On-board LED-Pin: GPIO1 (= TX-Pin)

Comment tirer le meilleur parti des broches et des leds limitées sur les modules WiFi ESP-01 et ESP-01S peu coûteux.

• Programmation de l'ESP-01 et de l'ESP-01S à l'aide des LED ESP-01S et ESP-01 Réglage
• de la valeur LED_BUILTIN
• Utilisation de TX/RX comme broches GPIO normales
• Débogage tout en utilisant RX comme broche GPIO normale
• Meilleur Pin Trick - Utiliser I2C
• Utilisation du GPIO0/GPIO2 pour OUTPUT et RX pour INPUT Comment reprogrammer
• lors de l'utilisation de GPIO0 comme sortie
• Relais scintillement au démarrage Détection du mode de configuration WiFi via
• l'entrée de broche Détection du mode de configuration WiFi via le logiciel
• Détection du bouton-poussoir de commande manuelle

ESP8266-01 est une puce compatible WiFi à très faible coût, mais avec peu d' E/S. À première vue, une fois que vous l'avez configuré pour la programmation, toutes les broches ont été utilisées. Cette page détaille l'utilisation des broches ESP8266 GPIO0/GPIO2/GPIO15 pour vous montrer comment vous pouvez obtenir quatre (4) entrées/sorties utilisables pour votre prochain projet ESP-01/ESP-01S et comment utiliser IC2 pour obtenir encore plus d'entrées. Il explique également comment piloter la LED bleue intégrée et contient des liens vers la programmation de l'ESP-01.

Le code ici suppose que vous programmez le module à l'aide de la configuration de l'IDE Arduino comme décrit sur sous Installing With Boards Manager . Lorsque vous ouvrez le gestionnaire de cartes à partir du menu Outils → Carte et sélectionnez Type Contribué et installez la plate-forme esp8266. Voir également les conseils de programmation ESP8266 (espcomm a échoué)

Ces deux cartes sont programmées à l'aide du paramètre de carte générique ESP8266 .

Avant de penser à la programmation, réfléchissez à la façon dont vous allez utiliser le module programmé. L'ESP-01(S) a besoin d'une alimentation 3V3 avec une capacité >250mA et des résistances externes supplémentaires. Il existe deux options de base qui vous offrent des capacités de programmation et de débogage :

1. vous construisez votre propre planche à pain avec une alimentation et des résistances comme indiqué dans ces projets ESP8266-01 Wifi Shield et Cheap NMEA/AIS Hub . Dans ces cas, vous devez utiliser un convertisseur USB vers 3V3 TTL tel qu'un câble série USB vers TTL 3V3 ou similaire.
2. vous utilisez un module pré-construit, tel que le module de relais ESP-01 utilisé dans ce projet ESP-01 Power Timer . Dans ces cas, vous devez utiliser un adaptateur série ESP-01 avec des broches de dérivation,Lien ESP V1.0 . Assurez-vous d'obtenir celui avec les broches supplémentaires à la fin.

Voir les projets ci-dessus pour savoir comment programmer l'ESP-01 à l'aide de ces options matérielles. Au lieu d'un câble série USB vers TTL 3V3, il est également possible de programmer l'ESP-01 à l'aide d'un Arduino UNO, en utilisant ce circuit , mais n'utilisez pas la broche d'alimentation UNO 3V3 car l'alimentation de l'ESP-01 est uniquement évaluée à 150mA et peut causer des problèmes lors de la tentative de débogage d'un projet qui utilise le WiFi.

Les ESP-01 et ESP-01S sont les plus petits modules ESP8266 et n'ont que 8 broches. Parmi celles-ci, VCC, GND, RST (réinitialisation) et CH_PD (sélection de puce) ne sont pas des broches d'E/S mais sont nécessaires au fonctionnement du module. Cela laisse GPIO0, GPIO2, TX et RX disponibles en tant que broches d'E/S possibles, mais même celles-ci ont des fonctions pré-assignées. Le GPIO0 et le GPIO2 déterminent le mode de démarrage du module et les broches TX/RX sont utilisées pour programmer le module et pour les E/S série, couramment utilisées pour le débogage.

GPIO0 et GPIO2 doivent avoir des résistances pull-up connectées pour garantir que le module démarre correctement. L'ESP-01S a des résistances 12K sur la carte pour GPIO0, RST et CH_PD (voir le schéma ci-dessus et aussi ici , copie locale ici )

L'ESP-01S n'a qu'une seule led, une led bleue connectée au GPIO2. Il s'allume lorsque GPIO2 est en sortie LOW. Il est simple à utiliser, il suffit de piloter GPIO2 car vous devez allumer et éteindre la led. Voici un croquis simple, ESP-01S_LedFlasher.ino , utilisant la classe PinFlasher pour faire clignoter la Led bleue sur un ESP-01S.

Pour l'ESP-01, les choses sont un peu plus difficiles. Il y a une led rouge qui s'allume lorsque le 3v3/GND est appliqué. Si vous voyez une led rouge, vous avez un ESP-01. Le voyant bleu de l'ESP-01 est piloté par la broche TX (GPIO1) et clignote normalement lorsque vous envoyez des données sur la connexion série. Cependant, si vous n'envoyez aucune donnée série (débogage), vous pouvez également piloter la broche GPIO1 pour piloter la LED normalement. Voici un autre croquis simple, ESP-01_LedFlasher.ino , pour piloter la led bleue ESP-01. Il a deux options. Si vous décommentez le #define DEBUG en haut, la série est démarrée et la LED bleue ne clignote pas mais clignote uniquement lorsque les messages de débogage sont envoyés. Si le #define DEBUG est commenté, la LED bleue clignote à intervalles d'une seconde.

La version récente d'Arduino IDE a un LED_BUILDIN prédéfini qui peut être utilisé comme broche connectée à la led des cartes. Cela pose un problème pour l'ESP-01 et l'ESP-01S qui sont tous deux programmés à l'aide du paramètre générique ESP8266 mais qui ont des broches différentes pour la led intégrée. Dans le menu Outils de l'ESP8266 V3.0.2+, sous le paramètre Board se trouve le paramètre Builtin Led . Cela ne change que la valeur que le LED_BUILTIN renverra. Si votre croquis utilise LED_BUILTIN, sélectionnez Builtin Led:1 pour l'ESP-01 et Builtin Led:2 pour l'ESP-01S.

Comme le montre le schéma ci-dessus, vous n'avez pas besoin de le faire uniquement pour piloter la LED bleue sur un ESP-01. Cependant, si vous utilisez GPIO1 (TX) pour piloter la led, cela laisse GPIO3 (RX) disponible en tant qu'E/S normale.

Si votre circuit utilise TX (GPIO1) comme sortie et RX (GPIO3) comme entrée, il vous suffit de ne pas appeler Serial.begin() car il s'agit du paramètre par défaut pour GPIO3.

Si vous avez besoin d'utiliser GPIO1 comme entrée ou GPIO3 comme sortie, il vous suffit d'appeler le pinMode( ) approprié soit INPUT, INPUT_PULLUP ou OUTPUT. Cet exemple d'esquisse, ESP-01S_tx_input.ino , utilise pinMode(1,INPUT) pour allumer/éteindre la led bleue via GPIO2.

N'oubliez pas que l'ESP8266 émet TOUJOURS un message de démarrage sur GPIO1, donc pendant ce court laps de temps, GPIO1 est TOUJOURS une sortie. Assurez-vous donc d'ajouter une résistance série 330R entre GPIO1 et la sortie qui pilote cette entrée pour éviter tout court-circuit pendant le message de démarrage.

La définition de GPIO3 (RX) en tant que SORTIE n'est PAS recommandée si vous pouvez l'éviter car il est facile de court-circuiter lors de la prochaine reprogrammation.

Notez attentivement : si vous utilisez GPIO3 (RX) comme sortie, ajoutez une petite résistance, par exemple 330R en série, pour éviter de la court-circuiter accidentellement lorsque vous connectez vos câbles de programmation. Une fois que vous avez commencé à utiliser GPIO1 (TX) et GPIO3 (RX) comme E/S normales, n'appelez pas Serial.begin(115200) car cela confondrait les choses (mais voir ensuite pour les alternatives). Impossible donc de déboguer à l'aide de la connexion série. Cependant, vous pouvez toujours déboguer via GPIO2 (TX uniquement) en démarrant Serial1 au lieu de Serial . Voir ce projet pour un exemple d'envoi de débogage à GPIO2.

Pour simplifier le débogage, vous pouvez également choisir de continuer à utiliser TX comme sortie de débogage standard tout en libérant RX (GPIO3) comme entrée en utilisant l'instruction
Serial.begin() Serial.begin( 115200,SERIAL_8N1,SERIAL_TX_ONLY);

Cela vous permet d'utiliser RX comme des E/S normales, tout en écrivant des messages de débogage sur Serial.

Ou <Serial.begin(115200,SERIAL_8N1,SERIAL_RX_ONLY); qui vous permet de recevoir une entrée série mais pas d'envoyer une sortie, mais laisse GPIO1 disponible pour une utilisation générale des E/S.

Ajoutez à nouveau une résistance de 330 ohms entre le fil RX et la connexion TX du programmeur Flash pour vous protéger contre les courts-circuits de la broche du programmeur ou de l'ESP s'il est connecté alors que RX est une sortie.

La meilleure astuce pour obtenir des entrées supplémentaires dans l'ESP8266-01 consiste à utiliser une interface I2C.

Un choix consiste à utiliser GPIO0 et GPIO2 comme bus I2C.

Les résistances de rappel nécessaires pour que le module démarre correctement peuvent doubler car les résistances de rappel du bus I2C et les autres composants esclaves du bus sont à collecteur ouvert et ne doivent donc pas abaisser le bus à la mise sous tension. Cependant, dans certains cas, les esclaves, en particulier ceux disposant d'une batterie de secours, peuvent rester bloqués et maintenir le bus enfoncé. Dans ces cas, vous devrez isoler le bus jusqu'à ce que l'ESP8266 passe par son stade de démarrage.

Vous pouvez éviter ce problème en utilisant TX et RX pour le bus I2C

Quelques points à noter :

1. GPIO1 (TX) est utilisé comme ligne de données, car vous obtiendrez toujours une sortie de débogage sur GPIO1 à la mise sous tension. Il n'y a aucun moyen de supprimer cette sortie, mais la ligne d'horloge (RX) sera maintenue haute afin qu'aucune de ces données ne soit cadencée vers les esclaves
2. Lors de la programmation de l'ESP8266, la ligne RX est connectée à la sortie du programmateur. À la fin de la programmation, l'ESP8266 redémarre et la résistance de protection 330 empêche RX de court-circuiter le lecteur de sortie du programmeur.
3. Les résistances de la série I2C offrent une protection similaire pour le TX, RX contre les courts-circuits sur le bus I2C

L'ESP8266 est un appareil 3,3 V, utilisez donc de préférence des esclaves I2C 3,3 V. De nombreux appareils I2C, mais pas tous, sont de nos jours à 3,3 V. "En général, dans un système où un appareil est à une tension plus élevée qu'un autre, il peut être possible de connecter les deux appareils via I2C sans aucun circuit de décalage de niveau entre eux. L'astuce consiste à connecter les résistances pull-up à la plus basse des deux tensions. ( Tutoriel SparkFun I2C ) Pour un mélange d'appareils 5V et 3,3V, connectez les résistances de rappel à la ligne 3,3V, comme indiqué ci-dessus.

L'utilisation d'I2C est un excellent moyen d'ajouter un convertisseur analogique-numérique multicanal à l'ESP8266-01 qui n'expose pas l'entrée ADC unique du module sous-jacent. Par exemple, en utilisant Adafruit 12bit I2C 4 canaux ADC ou pour la sortie analogique I2C DAC Breakout de SparkFun - carte MCP4725. De nombreux autres types de capteurs sont également disponibles avec des bus I2C.

Voir http://www.i2c-bus.org/i2c-primer/common-problems/ pour plus d'informations sur la résolution des problèmes I2C. Voir également Démarrage fiable pour I2C Battery Backed RTC pour une méthode courte pour aider à effacer le bus

Bien qu'il soit possible d'envoyer des messages de débogage via la connexion WiFi, il est souvent pratique d'utiliser la connexion TX. L'exemple suivant montre comment utiliser GPIO0 et GPIO2 comme sorties et RX comme entrée.

Utilisation
de Serial.begin(115200,SERIAL_8N1,SERIAL_TX_ONLY); vous permet d'utiliser RX comme entrée à usage général (ou une autre sortie), tout en écrivant des messages de débogage sur Serial. Encore une fois, la résistance de 330 ohms dans le câble RX du programmateur Flash protège contre les courts-circuits du pilote du programmateur.

REMARQUE : S1 devra être ouvert pour pouvoir programmer l'ESP8266.

La broche TX accessible à partir de l'esquisse en tant que GPIO1 et RX est GPIO3

Remarque : GPIO0 doit être mis à la terre pour passer en mode de programmation. Si vous dessinez le fait monter haut, le mettre à la terre peut endommager votre puce ESP8266.

Le moyen sûr de reprogrammer l'ESP8266 lorsque votre code pilote la sortie GPIO0 est de :

1. éteindre la carte
2. court-circuiter GPIO0 à la terre
3. allumer la carte qui passe en mode programme en raison du court-circuit sur GPIO0
4. supprimer le court-circuit de GPIO0 afin de ne pas court-circuiter la sortie lorsque le programme s'exécute
5. reprogrammer la carte
6. rallumer la carte si nécessaire.

Voici une autre façon de configurer les broches. Remarque : Cette astuce ne fonctionne que si vous avez un module relais avec une entrée isolée (N1 et N1-com). En raison de cette limitation et de la complexité du code de support, l'exemple précédent, utilisant RX comme entrée, est préférable.

L'utilisation des broches ESP8266 GPIO0/GPIO2/GPIO15 a déjà expliqué comment utiliser GPIO0/GPIO2 ensemble pour obtenir une entrée supplémentaire. Ici, cet exemple sera étendu pour utiliser GPIO0 comme sortie de pilote de relais et GPIO0/GPIO2 comme entrée sans utiliser RX ou TX.

le schéma en pdf

Ici, GPIO0 est utilisé comme sortie pour piloter le relais et GPIO0/GPIO2 est utilisé comme entrée pour lire le bouton-poussoir momentané qui est utilisé comme commande manuelle pour allumer et éteindre le relais, en plus de la télécommande via la connexion WiFi. Le bouton-poussoir momentané est également utilisé pour activer le mode de configuration s'il est enfoncé lors de la mise sous tension.

L'astuce ici est de faire tout cela tout en gardant GPIO0 et GPIO2 élevés lorsque le module ESP8266 s'initialise.

Les résistances de rappel, R1 et R3, fournissent le haut nécessaire pour ces deux broches, mais vous devez vous assurer que tout circuit supplémentaire attaché à GPIO0 et GPIO2 ne peut pas tirer les broches vers le bas. Le relais optiquement isolé est connecté entre +3,3V et GPIO0. Cela maintient GPIO0 à l'état haut au démarrage, mais permet à GPIO0 de devenir une sortie, après le démarrage, et de mettre à la terre l'entrée du relais pour faire fonctionner le relais. Peu importe si le bouton-poussoir momentané est actionné pendant l'initialisation du module, car cela connecte simplement GPIO0 à GPIO2 et connecte les deux à leurs résistances de rappel.

Lorsque l'ESP8266 s'allume/se réinitialise en mode normal, le GPIO0 devient BAS pendant environ 100 mS. Cela activera brièvement le relais connecté à GPIO0, illustré ci-dessous. Pour éviter ce scintillement du relais au démarrage, soudez un condensateur de 470 uF à 1000 uF 6,3 V ou supérieur sur les broches d'entrée de l'opto-isolateur (après la résistance intégrée) sur la carte relais elle-même. Vérifiez avec un multimètre pour obtenir la polarité du condensateur dans le bon sens. Ce condensateur retardera le commutateur de relais d'environ 0,5 s à 1 s. Vous pouvez essayer un condensateur aussi bas que 220 uF. Celui de 1000uF a été testé et fonctionne. le schéma en pdf

En utilisant l'ESP8266 comme point d'accès temporaire, vous pouvez le configurer via une page Web comme décrit ici . Vous pouvez utiliser un bouton-poussoir ou un lien de court-circuit à la mise sous tension pour indiquer au logiciel que vous souhaitez entrer en mode de configuration.

Une fois le module ESP8266 initialisé, il exécute le code setup() . Dans ce code, pour détecter si le bouton-poussoir momentané est enfoncé, vous n'avez pas besoin de rendre GPIO0 bas pour fournir un GND au bouton-poussoir, puis de vérifier l'entrée GPIO2 pour voir si elle est basse. Un effet secondaire de cette vérification est que le relais sera toujours activé lorsque l'unité est mise en mode de configuration. Une fois que vous voyez le relais fonctionner, vous pouvez relâcher le bouton-poussoir, car son entrée aura alors été détectée.

Voici un exemple de code pour le faire dans le setup()

boolean configMode = false;  // not in config mode normally
void setup() {
  pinMode(0, OUTPUT);
  digitalWrite(0, LOW); // make GPIO0 output LOW
  // check GPIO2 input to see if push button pressed connecting it to GPIO0
  configMode = (digitalRead(2) == LOW);
  if (configMode) {
    // start AP and get ready to serve config web page
    // leave relay on to indicate in config mode
    //......
  } else {
    // normal usage
    // make GPIO0 HIGH to turn off the relay
    digitalWrite(0, HIGH);
    //.....
  }
  // rest of setup()
}

Au lieu d'utiliser un bouton-poussoir ou un lien de court-circuit pour démarrer un point d'accès temporaire, vous pouvez le faire dans le logiciel. Ce projet, ESP-01 Power Timer , inclut les fichiers wifiConfig.cpp / .h. Le wifiConfig.cpp fournit deux options pour activer un point d'accès temporaire afin de configurer l'ESP8266 pour le SSID et le mot de passe de votre réseau. (Les fichiers LittleFSsupport.cpp / .h sont également nécessaires car ils sont utilisés pour gérer le système de fichiers FS)

Avec // #define DOUBLE_REBOOT_CONFIG_SETUP commenté, le premier appel à initializeWifiConfig() lit la configuration wifi existante à partir d'un fichier flash, ou définit les valeurs par défaut codées en dur et renvoie un pointeur vers le résultat. Dans la boucle principale, ESP8266_power_timer.ino, ceux-ci sont utilisés pour essayer de se connecter à votre réseau. S'il ne peut pas se connecter, après 30 secondes, initializeWifiConfig() est appelée à nouveau. Ce deuxième appel active le point d'accès temporaire afin que vous puissiez vous connecter directement à l'ESP8266 et ouvrir un navigateur à 10.1.1.1 pour définir le SSID et le mot de passe de votre réseau. Le nom du réseau WiFi le plus proche est automatiquement renseigné, mais vous pouvez le modifier si nécessaire.

Avec
#define DOUBLE_REBOOT_CONFIG_SETUP non commenté, wifiConfig.cpp implémente une version très simplifiée de ESP_DoubleResetDetector de Khoi Hoang . ( Stephen Denne a également un simple détecteur de double redémarrage qui utilise la mémoire RTC au lieu d'un fichier)

Dans ce mode, un point d'accès temporaire sera créé si vous allumez/réinitialisez l'ESP8266 et l'éteignez et le rallumez rapidement. Ce code utilise dans les 10 secondes comme définition de rapidement.

Dans les deux cas, le code loop() doit appeler

if (handleWifiConfig()) {
       return;
    }

près du haut de loop () pour gérer les mises à jour de wifiConfig et ignorer le reste de la boucle si vous êtes en mode config.

Enfin un QR code est fourni pour simplifier la connexion à ce point d'accès temporaire. Voir ESP-01 Power Timer pour savoir comment créer votre propre code.

La section précédente a couvert la détection du moment où le bouton-poussoir a été enfoncé lors de la mise sous tension pour activer le mode de configuration. Nous souhaitons également utiliser ce bouton-poussoir comme commande manuelle pour allumer et éteindre le relais en plus de pouvoir contrôler le relais via la liaison WiFi.

Le contrôle WiFi du relais n'est pas couvert ici, mais peut facilement être effectué à l'aide de pfodApp ou d'une page Web. Voir OLIMEX Menu Generator pour savoir comment générer du code Arduino avec pfodDesigner pour les modules ESP8266, ou ESP-01 Power Timer pour un exemple de page Web.

Cette section traitera de la façon de détecter le moment où le bouton-poussoir est enfoncé, indiquant que l'utilisateur veut basculer le relais, c'est-à-dire l'éteindre s'il est allumé ou l'allumer s'il est éteint.

Le schéma est le même que ci-dessus, toutes les astuces sont dans le code. Il y a deux cas à considérer :

1. Le relais est OFF et l'utilisateur veut l'allumer à l'aide du bouton poussoir,
2. Le relais est ON et l'utilisateur veut l'éteindre à l'aide du bouton poussoir.

Le relais est OFF et l'utilisateur souhaite l'activer à l'aide du bouton poussoir.
Dans ce cas, la sortie de GPIO0 est HIGH. En fait, GPIO0 peut être une entrée dans ce cas car la résistance de rappel R1 garantira que le relais ne s'allume pas. C'est le truc. Dans ce cas, faites de GPIO0 une entrée et faites de GPIO2 une sortie FAIBLE, puis lorsque l'utilisateur appuie sur le bouton-poussoir, deux choses se produiront : - a) le relais s'allumera en raison de la masse fournie par GPIO2 via le bouton-poussoir et b) l'entrée GPIO0 passera au niveau bas. Le code vérifie l'état de l'entrée GPIO0 et lorsqu'il passe au niveau BAS, le code sait que l'utilisateur a appuyé sur le bouton-poussoir et souhaite que le relais soit activé. Le code fait alors de GPIO0 une sortie LOW pour maintenir le relais activé lorsque le bouton-poussoir est relâché.

Le relais est ON et l'utilisateur veut l'éteindre à l'aide du bouton poussoir.

Dans ce cas, à la suite du cas ci-dessus, GPIO0 est une sortie LOW maintenant le relais ON. Maintenant, dans ce cas, faites de GPIO2 une entrée (tirée vers le haut par R3), puis lorsque l'utilisateur appuie sur le bouton-poussoir, l'entrée GPIO2 est tirée BAS par la sortie BAS sur GPIO0. Lorsque l'utilisateur relâche le bouton-poussoir, le code détecte la transition BAS à HAUT, puis fait de GPIO0 une entrée, qui libère le relais en raison de la résistance de rappel, R1, et fait de GPIO2 une sortie BAS à configurer pour le cas i) ci-dessus.

Encore une astuce. Pour le cas ii), nous avons besoin de GPIO2 comme entrée qui détecte une transition BAS à HAUT pour éteindre le relais. Mais si nous faisons GPIO2 et entrée à la fin du cas i), nous obtiendrons une transition BAS à HAUT lorsque l'utilisateur relâchera le bouton-poussoir qu'il vient d'appuyer pour allumer le relais. Pour éviter d'éteindre à nouveau le relais immédiatement, la première transition BAS à HAUT après avoir allumé le relais sera ignorée car c'est juste l'utilisateur qui relâche le bouton-poussoir sur lequel il a appuyé pour allumer le relais.

Dans ce code, j'ignore l'anti-rebond du commutateur pour plus de simplicité. Les entrées doivent être anti-rebond dans toute application réelle.

L'exemple de code est ici, ESP8266_01pinMagic_1.ino'

Encore une fois, cela laisse les broches TX / RX disponibles pour le débogage série ou les utiliser comme autres E/S

Cette page montre comment piloter la Led bleue et comment tirer le meilleur parti des broches limitées disponibles sur l'ESP-01 et l'ESP-01S. L'utilisation de GPIO0 / GPIO2 comme bus I2C offre la plus grande expansion, mais si votre projet n'utilise pas I2C, vous pouvez toujours piloter un relais et détecter une entrée de bouton-poussoir à l'aide de GPIO0 / GPIO2. Dans les deux cas, TX est toujours disponible pour le débogage série ou si vous envoyez des instructions d'impression de débogage via la liaison WiFi. TX et RX peuvent également être utilisés pour les E/S générales et GIOP2 peut être utilisé pour la sortie de débogage dans ce cas.