ESP32 Basic Starter
Trousse

Liste de colisage

Présentation de l'ESP32

Vous débutez avec l'ESP32 ? Commencez ici ! L'ESP32 est une série de microcontrôleurs SoC (System on a Chip) à faible coût et à faible consommation d'énergie développés par Espressif qui incluent des capacités sans fil Wi-Fi et Bluetooth et un processeur double cœur. Si vous connaissez l'ESP8266, l'ESP32 est son successeur, doté de nombreuses nouvelles fonctionnalités.Spécifications ESP32
Si vous souhaitez être un peu plus technique et spécifique, vous pouvez jeter un œil aux spécifications détaillées suivantes de l'ESP32 (source : http://esp32.net/) — pour plus de détails, vérifier la fiche technique):

• Connectivité sans fil WiFi : débit de données de 150.0 Mbps avec HT40
• Bluetooth : BLE (Bluetooth Low Energy) et Bluetooth Classic
• Processeur : Microprocesseur Tensilica Xtensa Dual-Core 32 bits LX6, cadencé à 160 ou 240 MHz
• Mémoire:
• ROM : 448 Ko (pour le démarrage et les fonctions principales)
• SRAM : 520 Ko (pour les données et les instructions)
• RTC fas SRAM : 8 Ko (pour le stockage des données et le processeur principal pendant le démarrage RTC à partir du mode veille prolongée)
• RTC slow SRAM : 8 Ko (pour l'accès au coprocesseur pendant le mode veille profonde) eFuse : 1 Kbit (dont 256 bits sont utilisés pour le système (adresse MAC et configuration de la puce) et les 768 bits restants sont réservés aux applications client, y compris le cryptage Flash et l'ID de puce)

Flash intégré : flash connecté en interne via IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 et SD_DATA_1 sur ESP32-D2WD et ESP32-PICO-D4.

• 0 Mio (puces ESP32-D0WDQ6, ESP32-D0WD et ESP32-S0WD)
• 2 Mio (puce ESP32-D2WD)
• 4 Mio (module SiP ESP32-PICO-D4)

Faible consommation : garantit que vous pouvez toujours utiliser les conversions ADC, par exempleample, pendant le sommeil profond.
Entrée/Sortie périphérique :

• interface périphérique avec DMA qui inclut le tactile capacitif
• ADC (convertisseur analogique-numérique)
• DAC (convertisseur numérique-analogique)
• I²C (Circuit Inter-Intégré)
• UART (récepteur/émetteur asynchrone universel)
• SPI (interface périphérique série)
• I²S (Son intégré entre puces)
• RMII (Interface réduite indépendante du support)
• PWM (modulation de largeur d'impulsion)

Sécurité: accélérateurs matériels pour AES et SSL/TLS

Cartes de développement ESP32

ESP32 fait référence à la puce ESP32 nue. Cependant, le terme « ESP32 » est également utilisé pour désigner les cartes de développement ESP32. L'utilisation de puces nues ESP32 n'est ni facile ni pratique, en particulier lors de l'apprentissage, des tests et du prototypage. La plupart du temps, vous souhaiterez utiliser une carte de développement ESP32.
Nous utiliserons la carte ESP32 DEVKIT V1 comme référence. L'image ci-dessous montre la carte ESP32 DEVKIT V1, version avec 30 broches GPIO.Spécifications – ESP32 DEVKIT V1
Le tableau suivant présente un résumé des fonctionnalités et des spécifications de la carte ESP32 DEVKIT V1 DOIT :

Nombre de cœurs	2 (double cœur)
Wifi	2.4 GHz jusqu'à 150 Mbits/s
Bluetooth	BLE (Bluetooth Low Energy) et Bluetooth hérité
Architecture	32 bits
Fréquence d'horloge	Jusqu'à 240 MHz
BÉLIER	512 Ko
Épingles	30 (selon le modèle)

Périphériques	Tactile capacitif, ADC (convertisseur analogique-numérique), DAC (convertisseur numérique-analogique), 12C (circuit inter-intégré), UART (récepteur/émetteur asynchrone universel), CAN 2.0 (Controller Area Network), SPI (interface périphérique série), 12S (Inter-IC intégré) Son), RMII (interface indépendante du support réduite), PWM (modulation de largeur d'impulsion) et bien plus encore.
Boutons intégrés	Boutons RESET et BOOT
LED intégrées	LED bleue intégrée connectée au GPIO2 ; LED rouge intégrée indiquant que la carte est alimentée
USB vers UART pont	CP2102

Il est livré avec une interface microUSB que vous pouvez utiliser pour connecter la carte à votre ordinateur afin de télécharger du code ou d'appliquer une alimentation.
Il utilise la puce CP2102 (USB vers UART) pour communiquer avec votre ordinateur via un port COM à l'aide d'une interface série. Une autre puce populaire est la CH340. Vérifiez quel est le convertisseur de puce USB vers UART sur votre carte, car vous devrez installer les pilotes requis pour que votre ordinateur puisse communiquer avec la carte (plus d'informations à ce sujet plus loin dans ce guide).
Cette carte est également équipée d'un bouton RESET (peut être étiqueté EN) pour redémarrer la carte et d'un bouton BOOT pour mettre la carte en mode flash (disponible pour recevoir le code). Notez que certaines cartes peuvent ne pas avoir de bouton BOOT.
Il est également équipé d'une LED bleue intégrée connectée en interne au GPIO 2. Cette LED est utile pour le débogage afin de fournir une sorte de sortie physique visuelle. Il existe également une LED rouge qui s'allume lorsque vous alimentez la carte.Brochage ESP32
Les périphériques ESP32 incluent :

• 18 canaux de convertisseur analogique-numérique (ADC)
• 3 Interfaces SPI
• 3 interfaces UART
• 2 interfaces I2C
• 16 canaux de sortie PWM
• 2 convertisseurs numériques-analogiques (DAC)
• 2 interfaces I2S
• 10 GPIO à détection capacitive

Les fonctions ADC (convertisseur analogique-numérique) et DAC (convertisseur numérique-analogique) sont attribuées à des broches statiques spécifiques. Cependant, vous pouvez décider quelles broches sont UART, I2C, SPI, PWM, etc. Il vous suffit de les attribuer dans le code. Cela est possible grâce à la fonction de multiplexage de la puce ESP32.
Bien que vous puissiez définir les propriétés des broches sur le logiciel, certaines broches sont attribuées par défaut comme indiqué dans la figure suivanteDe plus, il existe des broches avec des caractéristiques spécifiques qui les rendent adaptées ou non à un projet particulier. Le tableau suivant indique les broches les plus adaptées à utiliser comme entrées, sorties et celles auxquelles vous devez faire attention.
Les broches surlignées en vert peuvent être utilisées. Celles surlignées en jaune peuvent être utilisées, mais vous devez y prêter attention car elles peuvent avoir un comportement inattendu, principalement au démarrage. Il n'est pas recommandé d'utiliser les broches surlignées en rouge comme entrées ou sorties.

GP OI	Saisir	Sortir	Remarques
0	tiré vers le haut	OK	génère un signal PWM au démarrage, doit être BAS pour entrer en mode clignotant
1	Broche TX	OK	sortie de débogage au démarrage
2	OK	OK	connecté à la LED embarquée, doit être laissé flottant ou BAS pour entrer en mode clignotant
3	OK	Broche RX	HAUT au démarrage
4	OK	OK
5	OK	OK	génère un signal PWM au démarrage, broche de cerclage
12	OK	OK	le démarrage échoue s'il est tiré vers le haut, goupille de cerclage
13	OK	OK
14	OK	OK	génère un signal PWM au démarrage
15	OK	OK	génère un signal PWM au démarrage, broche de cerclage

16	OK	OK
17	OK	OK
18	OK	OK
19	OK	OK
21	OK	OK
22	OK	OK
23	OK	OK
25	OK	OK
26	OK	OK
27	OK	OK
32	OK	OK
33	OK	OK
34	OK		saisie uniquement
35	OK		saisie uniquement
36	OK		saisie uniquement
39	OK		saisie uniquement

Continuez à lire pour une analyse plus détaillée et approfondie des GPIO ESP32 et de leurs fonctions.
Broches d'entrée uniquement
Les GPIO 34 à 39 sont des GPI (broches d'entrée uniquement). Ces broches ne disposent pas de résistances internes de rappel vers le haut ou vers le bas. Elles ne peuvent pas être utilisées comme sorties, utilisez donc ces broches uniquement comme entrées :

• GPIO34
• GPIO35
• GPIO36
• GPIO39

Flash SPI intégré sur l'ESP-WROOM-32
Les broches GPIO 6 à GPIO 11 sont présentes sur certaines cartes de développement ESP32. Cependant, ces broches sont connectées au flash SPI intégré sur la puce ESP-WROOM-32 et ne sont pas recommandées pour d'autres utilisations. N'utilisez donc pas ces broches dans vos projets :

• GPIO 6 (SCK/CLK)
• GPIO 7 (SDO/SD0)
• GPIO 8 (SDI/SD1)
• GPIO 9 (SHD/SD2)
• GPIO 10 (SWP/SD3)
• GPIO 11 (CSC/CMD)

GPIO tactiles capacitifs
L'ESP32 dispose de 10 capteurs tactiles capacitifs internes. Ceux-ci peuvent détecter les variations de tout ce qui contient une charge électrique, comme la peau humaine. Ils peuvent donc détecter les variations induites lorsque l'on touche les GPIO avec un doigt. Ces broches peuvent être facilement intégrées dans des pads capacitifs et remplacer les boutons mécaniques. Les broches tactiles capacitives peuvent également être utilisées pour réveiller l'ESP32 d'un sommeil profond. Ces capteurs tactiles internes sont connectés à ces GPIO :

• T0 (GPIO 4)
• T1 (GPIO 0)
• T2 (GPIO 2)
• T3 (GPIO 15)
• T4 (GPIO 13)
• T5 (GPIO 12)
• T6 (GPIO 14)
• T7 (GPIO 27)
• T8 (GPIO 33)
• T9 (GPIO 32)

Convertisseur analogique-numérique (ADC)
L'ESP32 dispose de 18 canaux d'entrée ADC 12 bits (alors que l'ESP8266 n'a que 1 canal ADC 10 bits). Voici les GPIO qui peuvent être utilisés comme ADC et les canaux respectifs :

• ADC1_CH0 (GPIO 36)
• ADC1_CH1 (GPIO 37)
• ADC1_CH2 (GPIO 38)
• ADC1_CH3 (GPIO 39)
• ADC1_CH4 (GPIO 32)
• ADC1_CH5 (GPIO 33)
• ADC1_CH6 (GPIO 34)
• ADC1_CH7 (GPIO 35)
• ADC2_CH0 (GPIO 4)
• ADC2_CH1 (GPIO 0)
• ADC2_CH2 (GPIO 2)
• ADC2_CH3 (GPIO 15)
• ADC2_CH4 (GPIO 13)
• ADC2_CH5 (GPIO 12)
• ADC2_CH6 (GPIO 14)
• ADC2_CH7 (GPIO 27)
• ADC2_CH8 (GPIO 25)
• ADC2_CH9 (GPIO 26)

Note: Les broches ADC2 ne peuvent pas être utilisées lorsque le Wi-Fi est utilisé. Par conséquent, si vous utilisez le Wi-Fi et que vous avez du mal à obtenir la valeur d'un GPIO ADC2, vous pouvez envisager d'utiliser un GPIO ADC1 à la place. Cela devrait résoudre votre problème.
Les canaux d'entrée ADC ont une résolution de 12 bits. Cela signifie que vous pouvez obtenir des lectures analogiques allant de 0 à 4095, où 0 correspond à 0 V et 4095 à 3.3 V. Vous pouvez également définir la résolution de vos canaux sur le code et la plage ADC.
Les broches ADC de l'ESP32 n'ont pas un comportement linéaire. Vous ne pourrez probablement pas faire la distinction entre 0 et 0.1 V, ou entre 3.2 et 3.3 V. Vous devez garder cela à l'esprit lorsque vous utilisez les broches ADC. Vous obtiendrez un comportement similaire à celui illustré dans la figure suivante.Convertisseur numérique-analogique (DAC)
Il y a 2 canaux DAC 8 bits sur l'ESP32 pour convertir les signaux numériques en volume analogique.tage sorties de signal. Ce sont les canaux DAC :

• DAC1 (GPIO25)
• DAC2 (GPIO26)

GPIO RTC
L'ESP32 prend en charge les GPIO RTC. Les GPIO acheminés vers le sous-système basse consommation RTC peuvent être utilisés lorsque l'ESP32 est en veille profonde. Ces GPIO RTC peuvent être utilisés pour réveiller l'ESP32 du sommeil profond lorsque l'Ultra Low
Le coprocesseur Power (ULP) est en cours d'exécution. Les GPIO suivants peuvent être utilisés comme source de réveil externe.

• RTC_GPIO0 (GPIO36)
• RTC_GPIO3 (GPIO39)
• RTC_GPIO4 (GPIO34)
• RTC_GPIO5 (GPIO35)
• RTC_GPIO6 (GPIO25)
• RTC_GPIO7 (GPIO26)
• RTC_GPIO8 (GPIO33)
• RTC_GPIO9 (GPIO32)
• RTC_GPIO10 (GPIO4)
• RTC_GPIO11 (GPIO0)
• RTC_GPIO12 (GPIO2)
• RTC_GPIO13 (GPIO15)
• RTC_GPIO14 (GPIO13)
• RTC_GPIO15 (GPIO12)
• RTC_GPIO16 (GPIO14)
• RTC_GPIO17 (GPIO27)

Modulation de largeur d'impulsion (PWM)
Le contrôleur PWM LED ESP32 dispose de 16 canaux indépendants qui peuvent être configurés pour générer des signaux PWM avec différentes propriétés. Toutes les broches pouvant servir de sorties peuvent être utilisées comme broches PWM (les GPIO 34 à 39 ne peuvent pas générer de PWM).
Pour définir un signal PWM, vous devez définir ces paramètres dans le code :

• Fréquence du signal ;
• Cycle de service;
• canal PWM;
• GPIO où vous souhaitez émettre le signal.

I2C
L'ESP32 possède deux canaux I2C et n'importe quelle broche peut être définie comme SDA ou SCL. Lorsque vous utilisez l'ESP32 avec l'IDE Arduino, les broches I2C par défaut sont :

• GPIO21 (SDA)
• GPIO22 (SCL)

Si vous souhaitez utiliser d'autres broches lors de l'utilisation de la bibliothèque de fils, il vous suffit d'appeler :
Fil.begin(SDA, SCL);
SPI
Par défaut, le mappage des broches pour SPI est :

SPI	MOSI	MISO	CLK	CS
VSPI	GPIO23	GPIO19	GPIO18	GPIO5
HSPI	GPIO13	GPIO12	GPIO14	GPIO15

interruptions
Tous les GPIO peuvent être configurés comme des interruptions.
Goupilles de cerclage
La puce ESP32 possède les broches de cerclage suivantes :

• GPIO 0 (doit être BAS pour entrer en mode de démarrage)
• GPIO 2 (doit être flottant ou BAS pendant le démarrage)
• GPIO4
• GPIO 5 (doit être HAUT pendant le démarrage)
• GPIO 12 (doit être BAS pendant le démarrage)
• GPIO 15 (doit être HAUT pendant le démarrage)

Ces broches sont utilisées pour mettre l'ESP32 en mode bootloader ou flashing. Sur la plupart des cartes de développement avec USB/série intégré, vous n'avez pas à vous soucier de l'état de ces broches. La carte place les broches dans l'état approprié pour le mode flashing ou boot. Vous trouverez plus d'informations sur la sélection du mode de démarrage de l'ESP32 ici.
Cependant, si vous avez des périphériques connectés à ces broches, vous risquez d'avoir des difficultés à télécharger un nouveau code, à flasher l'ESP32 avec un nouveau micrologiciel ou à réinitialiser la carte. Si vous avez des périphériques connectés aux broches de cerclage et que vous rencontrez des difficultés pour télécharger du code ou flasher l'ESP32, cela peut être dû au fait que ces périphériques empêchent l'ESP32 d'entrer dans le bon mode. Lisez la documentation sur la sélection du mode de démarrage pour vous guider dans la bonne direction. Après la réinitialisation, le flashage ou le démarrage, ces broches fonctionnent comme prévu.
Les broches sont hautes au démarrage
Certains GPIO changent leur état sur HIGH ou émettent des signaux PWM au démarrage ou à la réinitialisation.
Cela signifie que si vous avez des sorties connectées à ces GPIO, vous pouvez obtenir des résultats inattendus lorsque l'ESP32 se réinitialise ou démarre.

• GPIO1
• GPIO3
• GPIO5
• GPIO 6 à GPIO 11 (connecté à la mémoire flash SPI intégrée de l'ESP32 - utilisation non recommandée).
• GPIO14
• GPIO15

Activer (FR)
Enable (EN) est la broche d'activation du régulateur 3.3 V. Elle est tirée vers le haut, donc connectez-la à la terre pour désactiver le régulateur 3.3 V. Cela signifie que vous pouvez utiliser cette broche connectée à un bouton-poussoir pour redémarrer votre ESP32, par exempleample.
Courant GPIO consommé
Le courant maximal absolu consommé par GPIO est de 40 mA selon la section « Conditions de fonctionnement recommandées » de la fiche technique de l'ESP32.
Capteur à effet Hall intégré ESP32
L'ESP32 dispose également d'un capteur à effet Hall intégré qui détecte les changements dans le champ magnétique de son environnement
IDE Arduino ESP32
Il existe un module complémentaire pour l'IDE Arduino qui vous permet de programmer l'ESP32 à l'aide de l'IDE Arduino et de son langage de programmation. Dans ce tutoriel, nous vous montrerons comment installer la carte ESP32 dans l'IDE Arduino, que vous utilisiez Windows, Mac OS X ou Linux.
Prérequis : Arduino IDE installé
Avant de commencer cette procédure d'installation, vous devez avoir installé Arduino IDE sur votre ordinateur. Il existe deux versions de l'IDE Arduino que vous pouvez installer : la version 1 et la version 2.
Vous pouvez télécharger et installer Arduino IDE en cliquant sur le lien suivant : arduino.cc/fr/Main/Logiciel
Quelle version d'Arduino IDE recommandons-nous ? Pour le moment, il existe quelques plugins pour l'ESP32 (comme le SPIFFS FileSystem Uploader Plugin) qui ne sont pas encore pris en charge sur Arduino 2. Par conséquent, si vous envisagez d'utiliser le plugin SPIFFS à l'avenir, nous vous recommandons d'installer la version héritée 1.8.X. Il vous suffit de faire défiler la page du logiciel Arduino pour le trouver.
Installation du module complémentaire ESP32 dans l'IDE Arduino
Pour installer la carte ESP32 dans votre IDE Arduino, suivez ces instructions suivantes :

1. Dans votre IDE Arduino, accédez à File> Préférences
2. Saisissez les informations suivantes dans le « Gestionnaire de cartes supplémentaires » URLchamp s" :

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Cliquez ensuite sur le bouton « OK » :Note: si vous possédez déjà les cartes ESP8266 URL, vous pouvez séparer le URLs avec une virgule comme suit :
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Ouvrez le gestionnaire de tableaux. Allez dans Outils > Tableau > Gestionnaire de tableaux…Recherchez ESP32 et appuyez sur le bouton d'installation de « ESP32 par Espressif Systems » :Voilà, ça y est, ça devrait être installé après quelques secondes.

Télécharger le code de test

Branchez la carte ESP32 sur votre ordinateur. Avec votre IDE Arduino ouvert, suivez ces étapes :

1. Sélectionnez votre carte dans le menu Outils > Carte (dans mon cas, c'est le module ESP32 DEV)
2. Sélectionnez le port (si vous ne voyez pas le port COM dans votre IDE Arduino, vous devez installer les pilotes VCP CP210x USB to UART Bridge) :
3. Ouvrez l'ex suivantample dessous File > Examples > WiFi
   (ESP32) > Analyse WiFi
4. Un nouveau croquis s'ouvre dans votre IDE Arduino :
5. Appuyez sur le bouton Télécharger dans l'IDE Arduino. Attendez quelques secondes pendant que le code se compile et se télécharge sur votre carte.
6. Si tout s’est déroulé comme prévu, vous devriez voir le message « Téléchargement terminé ».
7. Ouvrez le moniteur série Arduino IDE à un débit en bauds de 115200 XNUMX :
8. Appuyez sur le bouton d'activation intégré de l'ESP32 et vous devriez voir les réseaux disponibles à proximité de votre ESP32 :

Dépannage

Si vous essayez de télécharger un nouveau croquis sur votre ESP32 et que vous obtenez ce message d'erreur « Une erreur fatale s'est produite : Échec de la connexion à l'ESP32 : Délai d'attente expiré... Connexion en cours... », cela signifie que votre ESP32 n'est pas en mode flash/téléchargement.
Après avoir sélectionné le bon nom de carte et le port COM, suivez ces étapes :
Maintenez enfoncé le bouton « BOOT » de votre carte ESP32

• Appuyez sur le bouton « Télécharger » dans l’IDE ​​Arduino pour télécharger votre croquis :
• Après avoir vu le message « Connexion… » dans votre IDE Arduino, relâchez le doigt du bouton « BOOT » :
• Après cela, vous devriez voir le message « Téléchargement terminé »
  Voilà. Votre ESP32 devrait exécuter le nouveau croquis. Appuyez sur le bouton « ENABLE » pour redémarrer l'ESP32 et exécuter le nouveau croquis téléchargé.
  Vous devrez également répéter cette séquence de boutons chaque fois que vous souhaitez télécharger un nouveau croquis.

Projet 1 Entrées Sorties ESP32

Dans ce guide de démarrage, vous apprendrez à lire les entrées numériques comme un interrupteur à bouton et à contrôler les sorties numériques comme une LED à l'aide de l'ESP32 avec Arduino IDE.
Prérequis
Nous allons programmer l'ESP32 à l'aide de l'IDE Arduino. Assurez-vous donc que le module complémentaire de cartes ESP32 est installé avant de continuer :

• Installation du module complémentaire ESP32 dans l'IDE Arduino

Sorties numériques de contrôle ESP32
Tout d'abord, vous devez définir le GPIO que vous souhaitez contrôler comme SORTIE. Utilisez la fonction pinMode() comme suit :
pinMode(GPIO, SORTIE);
Pour contrôler une sortie numérique, il vous suffit d'utiliser la fonction digitalWrite(), qui accepte comme arguments, le GPIO (numéro int) auquel vous faites référence et l'état, soit HIGH ou LOW.
digitalWrite(GPIO, ETAT);
Tous les GPIO peuvent être utilisés comme sorties, à l'exception des GPIO 6 à 11 (connectés au flash SPI intégré) et des GPIO 34, 35, 36 et 39 (GPIO d'entrée uniquement) ;
En savoir plus sur les GPIO ESP32 : Guide de référence des GPIO ESP32
Entrées numériques de lecture ESP32
Tout d’abord, définissez le GPIO que vous souhaitez lire comme ENTRÉE, en utilisant la fonction pinMode() comme suit :
pinMode(GPIO, ENTRÉE);
Pour lire une entrée numérique, comme un bouton, vous utilisez la fonction digitalRead(), qui accepte comme argument, le GPIO (numéro int) auquel vous faites référence.
lecturenumérique(GPIO);
Tous les GPIO ESP32 peuvent être utilisés comme entrées, à l'exception des GPIO 6 à 11 (connectés au flash SPI intégré).
En savoir plus sur les GPIO ESP32 : Guide de référence des GPIO ESP32
Projet Example
Pour vous montrer comment utiliser les entrées et les sorties numériques, nous allons créer un exemple de projet simpleample avec un bouton poussoir et une LED. Nous allons lire l'état du bouton poussoir et allumer la LED en conséquence comme illustré dans la figure suivante.

Pièces requises
Voici une liste des pièces dont vous avez besoin pour construire le circuit :

• Kit de développement ESP32 V1
• DEL 5 mm
• Résistance de 220 Ohms
• Pushbutton
• Résistance 10 XNUMX ohms
• Planche à pain
• Fils de liaison

Diagramme schématique
Avant de continuer, vous devez assembler un circuit avec une LED et un bouton poussoir.
Nous allons connecter la LED au GPIO 5 et le bouton poussoir au GPIO 4.Code
Ouvrez le code Project_1_ESP32_Inputs_Outputs.ino dans l'IDE ArduinoComment fonctionne le code
Dans les deux lignes suivantes, vous créez des variables pour affecter des broches :

Le bouton est connecté au GPIO 4 et la LED est connectée au GPIO 5. Lors de l'utilisation de l'IDE Arduino avec l'ESP32, 4 correspond au GPIO 4 et 5 correspond au GPIO 5.
Ensuite, vous créez une variable pour conserver l'état du bouton. Par défaut, c'est 0 (non enfoncé).
int buttonState = 0;
Dans le setup(), vous initialisez le bouton comme une ENTRÉE et la LED comme une SORTIE.
Pour cela, vous utilisez la fonction pinMode() qui accepte la broche à laquelle vous faites référence, et le mode : INPUT ou OUTPUT.
pinMode(boutonPin, ENTRÉE);
pinMode(ledPin, SORTIE);
Dans la boucle(), vous lisez l'état du bouton et définissez la LED en conséquence.
Dans la ligne suivante, vous lisez l’état du bouton et l’enregistrez dans la variable buttonState.
Comme nous l'avons vu précédemment, vous utilisez la fonction digitalRead().
buttonState = digitalRead(boutonPin);
L'instruction if suivante vérifie si l'état du bouton est HAUT. Si c'est le cas, elle allume la LED à l'aide de la fonction digitalWrite() qui accepte comme argument la ledPin et l'état HAUT.
si (buttonState == HAUT)Si l'état du bouton n'est pas HAUT, vous désactivez la LED. Définissez simplement LOW comme deuxième argument dans la fonction digitalWrite().Télécharger le code
Avant de cliquer sur le bouton de téléchargement, allez dans Outils > Carte et sélectionnez la carte : DOIT ESP32 DEVKIT V1 board.
Accédez à Outils > Port et sélectionnez le port COM auquel l'ESP32 est connecté. Appuyez ensuite sur le bouton de téléchargement et attendez le message « Téléchargement terminé ».Remarque : si vous voyez beaucoup de points (connexion…__…__) dans la fenêtre de débogage et le message « Échec de la connexion à l'ESP32 : délai d'attente de l'en-tête du paquet expiré », cela signifie que vous devez appuyer sur le bouton BOOT intégré de l'ESP32 après les points
commencent à apparaître.Dépannage

Démonstration

Après avoir téléchargé le code, testez votre circuit. Votre LED doit s'allumer lorsque vous appuyez sur le bouton poussoir :Et s'éteint lorsque vous le relâchez :

Projet 2 Entrées analogiques ESP32

Ce projet montre comment lire les entrées analogiques avec l'ESP32 à l'aide d'Arduino IDE.
La lecture analogique est utile pour lire les valeurs des résistances variables comme les potentiomètres ou les capteurs analogiques.
Entrées analogiques (ADC)
La lecture d'une valeur analogique avec l'ESP32 signifie que vous pouvez mesurer des variations de volumetage niveaux entre 0 V et 3.3 V.
Le voltagLa valeur mesurée est alors attribuée à une valeur comprise entre 0 et 4095, dans laquelle 0 V correspond à 0 et 3.3 V correspond à 4095. Tout voltaget entre 0 V et 3.3 V recevra la valeur correspondante entre les deux.L'ADC est non linéaire
Idéalement, vous vous attendriez à un comportement linéaire lors de l’utilisation des broches ADC ESP32.
Mais ce n'est pas le cas. Vous obtiendrez un comportement tel que celui illustré dans le tableau suivant :Ce comportement signifie que votre ESP32 n'est pas capable de distinguer 3.3 V de 3.2 V.
Vous obtiendrez la même valeur pour les deux volumestagfr: 4095.
La même chose se produit pour les très faibles volumestagvaleurs : pour 0 V et 0.1 V, vous obtiendrez la même valeur : 0. Vous devez garder cela à l'esprit lorsque vous utilisez les broches ADC ESP32.
Fonction analogRead()
Lire une entrée analogique avec l'ESP32 en utilisant l'IDE Arduino est aussi simple que d'utiliser la fonction analogRead(). Elle accepte comme argument le GPIO que vous souhaitez lire :
lecture analogique (GPIO);
Seuls 15 sont disponibles dans la carte DEVKIT V1 (version avec 30 GPIO).
Prenez le brochage de votre carte ESP32 et localisez les broches ADC. Celles-ci sont mises en évidence par une bordure rouge dans la figure ci-dessous.Ces broches d'entrée analogiques ont une résolution de 12 bits. Cela signifie que lorsque vous lisez une entrée analogique, sa plage peut varier de 0 à 4095.
Remarque : les broches ADC2 ne peuvent pas être utilisées lorsque le Wi-Fi est utilisé. Par conséquent, si vous utilisez le Wi-Fi et que vous rencontrez des difficultés pour obtenir la valeur d'un GPIO ADC2, vous pouvez envisager d'utiliser un GPIO ADC1 à la place, ce qui devrait résoudre votre problème.
Pour voir comment tout cela s'articule, nous allons faire un exemple simpleamppermet de lire une valeur analogique à partir d'un potentiomètre.
Pièces requises
Pour cet example, vous avez besoin des pièces suivantes :

• Carte ESP32 DEVKIT V1
• Potentiomètre
• Planche à pain
• Fils de liaison

Schématique
Connectez un potentiomètre à votre ESP32. La broche centrale du potentiomètre doit être connectée au GPIO 4. Vous pouvez utiliser le schéma suivant comme référence.Code
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Ouvrez le code Project_2_ESP32_Inputs_Outputs.ino dans l'IDE ArduinoCe code lit simplement les valeurs du potentiomètre et imprime ces valeurs dans le moniteur série.
Dans le code, vous commencez par définir le GPIO auquel le potentiomètre est connecté. Dans cet exempleample, GPIO 4.Dans le setup(), initialisez une communication série à un débit en bauds de 115200 XNUMX.Dans la boucle(), utilisez la fonction analogRead() pour lire l'entrée analogique du potPin.Enfin, imprimez les valeurs lues à partir du potentiomètre dans le moniteur série.Téléchargez le code fourni sur votre ESP32. Assurez-vous que la bonne carte et le bon port COM sont sélectionnés dans le menu Outils.
Tester l'Example
Après avoir téléchargé le code et appuyé sur le bouton de réinitialisation de l'ESP32, ouvrez le moniteur série à un débit en bauds de 115200 XNUMX. Tournez le potentiomètre et voyez les valeurs changer.La valeur maximale que vous obtiendrez est 4095 et la valeur minimale est 0.

Pour conclure

Dans cet article, vous avez appris à lire les entrées analogiques à l'aide de l'ESP32 avec l'IDE Arduino. En résumé :

• La carte ESP32 DEVKIT V1 DOIT (version avec 30 broches) dispose de 15 broches ADC que vous pouvez utiliser pour lire les entrées analogiques.
• Ces broches ont une résolution de 12 bits, ce qui signifie que vous pouvez obtenir des valeurs de 0 à 4095.
• Pour lire une valeur dans l'IDE Arduino, utilisez simplement la fonction analogRead().
• Les broches ADC de l'ESP32 n'ont pas un comportement linéaire. Vous ne pourrez probablement pas faire la distinction entre 0 et 0.1 V, ou entre 3.2 et 3.3 V. Vous devez garder cela à l'esprit lorsque vous utilisez les broches ADC.

Projet 3 ESP32 PWM (sortie analogique)

Dans ce tutoriel, nous vous montrerons comment générer des signaux PWM avec l'ESP32 à l'aide d'Arduino IDE. En tant qu'exampnous allons construire un circuit simple qui atténue une LED en utilisant le contrôleur LED PWM de l'ESP32.Contrôleur PWM LED ESP32
L'ESP32 dispose d'un contrôleur LED PWM avec 16 canaux indépendants qui peuvent être configurés pour générer des signaux PWM avec différentes propriétés.
Voici les étapes à suivre pour atténuer une LED avec PWM en utilisant l'IDE Arduino :

1. Tout d'abord, vous devez choisir un canal PWM. Il existe 16 canaux de 0 à 15.
2. Ensuite, vous devez définir la fréquence du signal PWM. Pour une LED, une fréquence de 5000 XNUMX Hz est suffisante.
3. Vous devez également définir la résolution du cycle de service du signal : vous disposez de résolutions de 1 à 16 bits. Nous utiliserons une résolution de 8 bits, ce qui signifie que vous pouvez contrôler la luminosité de la LED à l'aide d'une valeur comprise entre 0 et 255.
4.  Ensuite, vous devez spécifier sur quel(s) GPIO le signal apparaîtra. Pour cela, vous utiliserez la fonction suivante :
   ledcAttachPin(GPIO, canal)
   Cette fonction accepte deux arguments. Le premier est le GPIO qui va générer le signal, et le second est le canal qui va générer le signal.
5. Enfin, pour contrôler la luminosité des LED à l'aide de PWM, vous utilisez la fonction suivante :

ledcWrite(canal, rapport cyclique)
Cette fonction accepte comme arguments le canal qui génère le signal PWM et le cycle de service.
Pièces requises
Pour suivre ce tutoriel, vous avez besoin de ces pièces :

• Carte ESP32 DEVKIT V1
• 5mm LED
• Résistance de 220 Ohms
•  Planche à pain
• Fils de liaison

Schématique
Connectez une LED à votre ESP32 comme dans le schéma suivant. La LED doit être connectée au GPIO 4.Note: Vous pouvez utiliser n'importe quelle broche de votre choix, à condition qu'elle puisse servir de sortie. Toutes les broches pouvant servir de sorties peuvent être utilisées comme broches PWM. Pour plus d'informations sur les GPIO de l'ESP32, lisez : Référence de brochage ESP32 : Quelles broches GPIO devez-vous utiliser ?
Code
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Ouvrez le code Project_3_ESP32_PWM.ino dans l'IDE ArduinoVous commencez par définir la broche à laquelle la LED est attachée. Dans ce cas, la LED est attachée au GPIO 4.Ensuite, vous définissez les propriétés du signal PWM. Vous définissez une fréquence de 5000 0 Hz, choisissez le canal 8 pour générer le signal et définissez une résolution de XNUMX bits. Vous pouvez choisir d'autres propriétés, différentes de celles-ci, pour générer différents signaux PWM.Dans le setup(), vous devez configurer la LED PWM avec les propriétés que vous avez définies précédemment en utilisant la fonction ledcSetup() qui accepte comme arguments, le ledChannel, la fréquence et la résolution, comme suit :Ensuite, vous devez choisir le GPIO à partir duquel vous obtiendrez le signal. Pour cela, utilisez la fonction ledcAttachPin() qui accepte comme arguments le GPIO où vous souhaitez obtenir le signal et le canal qui génère le signal. Dans cet exempleample, nous allons obtenir le signal dans le ledPin GPIO, qui correspond au GPIO 4. Le canal qui génère le signal est le ledChannel, qui correspond au canal 0.Dans la boucle, vous ferez varier le cycle de service entre 0 et 255 pour augmenter la luminosité de la LED.Et puis, entre 255 et 0 pour diminuer la luminosité.Pour régler la luminosité de la LED, il suffit d'utiliser la fonction ledcWrite() qui accepte comme arguments le canal qui génère le signal et le rapport cyclique.Comme nous utilisons une résolution de 8 bits, le cycle de service sera contrôlé à l'aide d'une valeur de 0 à 255. Notez que dans la fonction ledcWrite(), nous utilisons le canal qui génère le signal, et non le GPIO.

Tester l'Example

Téléchargez le code sur votre ESP32. Assurez-vous que vous avez sélectionné la bonne carte et le bon port COM. Regardez votre circuit. Vous devriez avoir une LED à intensité variable qui augmente et diminue la luminosité.

Projet 4 ESP32 Capteur de mouvement PIR

Ce projet montre comment détecter un mouvement avec l'ESP32 à l'aide d'un capteur de mouvement PIR. Le buzzer émet une alarme lorsqu'un mouvement est détecté et arrête l'alarme lorsqu'aucun mouvement n'est détecté pendant une durée prédéfinie (par exemple 4 secondes).
Comment fonctionne le détecteur de mouvement HC-SR501
.Le principe de fonctionnement du capteur HC-SR501 est basé sur le changement du rayonnement infrarouge sur l'objet en mouvement. Pour être détecté par le capteur HC-SR501, l'objet doit répondre à deux exigences :

• L'objet émet de manière infrarouge.
• L'objet bouge ou tremble

Donc:
Si un objet émet un rayon infrarouge mais ne bouge pas (par exemple, une personne reste immobile sans bouger), il n'est pas détecté par le capteur.
Si un objet est en mouvement mais n'émet pas de rayon infrarouge (par exemple, un robot ou un véhicule), il n'est PAS détecté par le capteur.
Présentation des minuteurs
Dans cet exampNous allons également introduire des minuteurs. Nous voulons que la LED reste allumée pendant un nombre de secondes prédéterminé après la détection d'un mouvement. Au lieu d'utiliser une fonction delay() qui bloque votre code et ne vous permet pas de faire autre chose pendant un nombre de secondes déterminé, nous devrions utiliser un minuteur.La fonction delay()
Vous devez être familier avec la fonction delay() car elle est largement utilisée. Cette fonction est assez simple à utiliser. Elle accepte un seul nombre int comme argument.
Ce nombre représente le temps en millisecondes que le programme doit attendre avant de passer à la ligne de code suivante.Lorsque vous effectuez un delay(1000), votre programme s'arrête sur cette ligne pendant 1 seconde.
delay() est une fonction de blocage. Les fonctions de blocage empêchent un programme de faire autre chose jusqu'à ce que cette tâche particulière soit terminée. Si vous avez besoin que plusieurs tâches se produisent en même temps, vous ne pouvez pas utiliser delay().
Pour la plupart des projets, vous devriez éviter d'utiliser des délais et utiliser des minuteries à la place.
La fonction millis()
En utilisant une fonction appelée millis(), vous pouvez renvoyer le nombre de millisecondes qui se sont écoulées depuis le premier démarrage du programme.Pourquoi cette fonction est-elle utile ? Parce qu'en utilisant quelques mathématiques, vous pouvez facilement vérifier combien de temps s'est écoulé sans bloquer votre code.
Pièces requises
Pour suivre ce tutoriel, vous avez besoin des pièces suivantes

• Carte ESP32 DEVKIT V1
• Capteur de mouvement PIR (HC-SR501)
• Buzzer actif
• Fils de liaison
• Planche à pain

SchématiqueNote: Le volume de travailtagLa tension d'alimentation du HC-SR501 est de 5 V. Utilisez la broche Vin pour l'alimenter.
Code
Avant de poursuivre ce tutoriel, vous devez avoir installé le module complémentaire ESP32 dans votre IDE Arduino. Suivez l'un des tutoriels suivants pour installer l'ESP32 sur l'IDE Arduino, si vous ne l'avez pas déjà fait. (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Ouvrez le code Project_4_ESP32_PIR_Motion_Sensor.ino dans Arduino IDE.
Démonstration
Téléchargez le code sur votre carte ESP32. Assurez-vous d'avoir sélectionné la bonne carte et le bon port COM. Étapes de référence pour télécharger le code.
Ouvrez le moniteur série à un débit en bauds de 115200 XNUMX.Placez votre main devant le capteur PIR. Le buzzer doit s'allumer et le message « Mouvement détecté ! Alarme sonore » s'affiche sur le moniteur série.
Après 4 secondes, le buzzer devrait s'éteindre.

Projet 5 Commutateur ESP32 Web Serveur

Dans ce projet, vous allez créer un web serveur avec un ESP32 qui contrôle les sorties (deux LED) à l'aide de l'environnement de programmation Arduino IDE. web Le serveur est réactif et peut être consulté avec n'importe quel appareil qui utilise un navigateur sur le réseau local. Nous vous montrerons comment créer le web serveur et comment le code fonctionne étape par étape.
Surplomberview
Avant de passer directement au projet, il est important de décrire ce que notre web le serveur fera l'affaire, afin qu'il soit plus facile de suivre les étapes ultérieurement.

• Le web le serveur que vous allez construire contrôle deux LED connectées aux ESP32 GPIO 26 et GPIO 27 ;
• Vous pouvez accéder à l'ESP32 web serveur en tapant l'adresse IP ESP32 sur un navigateur du réseau local ;
• En cliquant sur les boutons de votre web serveur, vous pouvez changer instantanément l'état de chaque LED.

Pièces requises
Pour ce tutoriel, vous aurez besoin des pièces suivantes :

• Carte ESP32 DEVKIT V1
• 2 LED de 5 mm
• 2x résistance de 200 ohms
• Planche à pain
• Fils de liaison

Schématique
Commencez par construire le circuit. Connectez deux LED à l'ESP32 comme indiqué dans le schéma suivant : une LED connectée au GPIO 26 et l'autre au GPIO 27.
Note: Nous utilisons la carte ESP32 DEVKIT DOIT avec 36 broches. Avant d'assembler le circuit, assurez-vous de vérifier le brochage de la carte que vous utilisez.Code
Nous fournissons ici le code qui crée l'ESP32 web serveur. Ouvrez le code Project_5_ESP32_Switch _Web_Server.ino dans Arduino IDE, mais ne le téléchargez pas encore. Vous devez apporter quelques modifications pour le faire fonctionner pour vous.
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Définition de vos identifiants réseau
Vous devez modifier les lignes suivantes avec vos identifiants réseau : SSID et mot de passe. Le code est bien commenté sur les endroits où vous devez effectuer les modifications.Télécharger le code
Maintenant, vous pouvez télécharger le code et le web le serveur fonctionnera immédiatement.
Suivez les étapes suivantes pour télécharger le code sur l'ESP32 :

1. Branchez votre carte ESP32 sur votre ordinateur ;
2. Dans l'IDE Arduino, sélectionnez votre carte dans Outils > Carte (dans notre cas, nous utilisons la carte ESP32 DEVKIT DOIT) ;
3. Sélectionnez le port COM dans Outils > Port.
4. Appuyez sur le bouton Télécharger dans l'IDE Arduino et attendez quelques secondes pendant que le code se compile et se télécharge sur votre carte.
5. Attendez le message « Téléchargement terminé ».

Trouver l'adresse IP ESP
Après avoir téléchargé le code, ouvrez le moniteur série à un débit en bauds de 115200 XNUMX.Appuyez sur le bouton ESP32 EN (réinitialisation). L'ESP32 se connecte au Wi-Fi et affiche l'adresse IP ESP sur le moniteur série. Copiez cette adresse IP, car vous en avez besoin pour accéder à l'ESP32 web serveur.Accéder à la Web Serveur
Pour accéder au web serveur, ouvrez votre navigateur, collez l'adresse IP ESP32 et vous verrez la page suivante.
Note: Votre navigateur et ESP32 doivent être connectés au même réseau local.Si vous jetez un œil au moniteur série, vous pouvez voir ce qui se passe en arrière-plan. L'ESP reçoit une requête HTTP d'un nouveau client (dans ce cas, votre navigateur).Vous pouvez également voir d'autres informations sur la requête HTTP.
Démonstration
Vous pouvez maintenant tester si votre web le serveur fonctionne correctement. Cliquez sur les boutons pour contrôler les LED.En même temps, vous pouvez jeter un œil au moniteur série pour voir ce qui se passe en arrière-plan. Par exempleample, lorsque vous cliquez sur le bouton pour activer le GPIO 26, l'ESP32 reçoit une requête sur le /26/on URL.Lorsque l'ESP32 reçoit cette demande, il allume la LED attachée au GPIO 26 et met à jour son état sur le web page.Le bouton GPIO 27 fonctionne de manière similaire. Vérifiez qu'il fonctionne correctement.

Comment fonctionne le code

Dans cette section, nous examinerons de plus près le code pour voir comment il fonctionne.
La première chose que vous devez faire est d’inclure la bibliothèque WiFi.Comme mentionné précédemment, vous devez insérer votre SSID et votre mot de passe dans les lignes suivantes à l'intérieur des guillemets.Ensuite, vous définissez votre web serveur sur le port 80.La ligne suivante crée une variable pour stocker l'en-tête de la requête HTTP :Ensuite, vous créez des variables auxiliaires pour stocker l'état actuel de vos sorties. Si vous souhaitez ajouter d'autres sorties et enregistrer leur état, vous devez créer davantage de variables.Vous devez également attribuer un GPIO à chacune de vos sorties. Ici, nous utilisons le GPIO 26 et le GPIO 27. Vous pouvez utiliser tout autre GPIO approprié.installation()
Passons maintenant à la fonction setup(). Tout d'abord, nous démarrons une communication série à un débit en bauds de 115200 XNUMX à des fins de débogage.Vous définissez également vos GPIO comme SORTIES et les réglez sur FAIBLE.Les lignes suivantes démarrent la connexion Wi-Fi avec WiFi.begin(ssid, password), attendent une connexion réussie et impriment l'adresse IP ESP dans le moniteur série.boucle()
Dans la boucle(), nous programmons ce qui se passe lorsqu'un nouveau client établit une connexion avec le web serveur.
L'ESP32 est toujours à l'écoute des clients entrants avec la ligne suivante :Lorsqu'une requête est reçue d'un client, nous enregistrons les données entrantes. La boucle while qui suit s'exécutera tant que le client restera connecté. Nous vous déconseillons de modifier la partie suivante du code à moins que vous ne sachiez exactement ce que vous faites.La section suivante des instructions if et else vérifie quel bouton a été appuyé dans votre web page et contrôle les sorties en conséquence. Comme nous l'avons vu précédemment, nous faisons une demande sur différents URLs en fonction du bouton appuyé.Par exempleample, si vous avez appuyé sur le bouton GPIO 26 ON, l'ESP32 reçoit une requête sur le /26/ON URL (nous pouvons voir ces informations sur l'en-tête HTTP du moniteur série). Nous pouvons donc vérifier si l'en-tête contient l'expression GET /26/on. Si c'est le cas, nous modifions la variable output26state sur ON, et l'ESP32 allume la LED.
Cela fonctionne de la même manière pour les autres boutons. Ainsi, si vous souhaitez ajouter d'autres sorties, vous devez modifier cette partie du code pour les inclure.
Affichage du code HTML web page
La prochaine chose que vous devez faire est de créer le web page. L'ESP32 enverra une réponse à votre navigateur avec du code HTML pour créer le web page.
Le web la page est envoyée au client en utilisant cette expression client.println(). Vous devez entrer ce que vous souhaitez envoyer au client comme argument.
La première chose que nous devons envoyer est toujours la ligne suivante, qui indique que nous envoyons du HTML.Ensuite, la ligne suivante fait le web page réactive dans n'importe quel web navigateur.Et ce qui suit est utilisé pour empêcher les requêtes sur le favicon. – Vous n'avez pas à vous soucier de cette ligne.

Styliser le Web Page

Ensuite, nous avons du texte CSS pour styliser les boutons et le web apparence de la page.
Nous choisissons la police Helvetica, définissons le contenu à afficher sous forme de bloc et aligné au centre.Nous stylisons nos boutons avec la couleur #4CAF50, sans bordure, le texte en couleur blanche et avec ce remplissage : 16px 40px. Nous définissons également la décoration du texte sur aucune, définissons la taille de la police, la marge et le curseur sur un pointeur.Nous définissons également le style d'un deuxième bouton, avec toutes les propriétés du bouton que nous avons défini précédemment, mais avec une couleur différente. Ce sera le style du bouton d'arrêt.

Réglage de la Web Page 1 Titre
Dans la ligne suivante, vous pouvez définir le premier titre de votre web page. Ici nous avons « ESP32 Web Serveur”, mais vous pouvez modifier ce texte comme vous le souhaitez.Affichage des boutons et de l'état correspondant
Ensuite, vous écrivez un paragraphe pour afficher l'état actuel du GPIO 26. Comme vous pouvez le voir, nous utilisons la variable output26State, de sorte que l'état se met à jour instantanément lorsque cette variable change.Ensuite, nous affichons le bouton marche ou arrêt, en fonction de l'état actuel du GPIO. Si l'état actuel du GPIO est éteint, nous affichons le bouton ON, sinon, nous affichons le bouton OFF.Nous utilisons la même procédure pour GPIO 27.
Fermeture de la connexion
Enfin, lorsque la réponse se termine, nous effaçons la variable d'en-tête et arrêtons la connexion avec le client avec client.stop().

Pour conclure

Dans ce tutoriel, nous vous avons montré comment créer un web serveur avec l'ESP32. Nous vous avons montré un exemple simpleample qui contrôle deux LED, mais l'idée est de remplacer ces LED par un relais, ou toute autre sortie que vous souhaitez contrôler.

Projet 6 LED RVB Web Serveur

Dans ce projet, nous vous montrerons comment contrôler à distance une LED RVB avec une carte ESP32 à l'aide d'un web serveur avec un sélecteur de couleurs.
Surplomberview
Avant de commencer, voyons comment fonctionne ce projet :

• L'ESP32 web le serveur affiche un sélecteur de couleurs.
• Lorsque vous choisissez une couleur, votre navigateur fait une requête sur un URL qui contient les paramètres R, G et B de la couleur sélectionnée.
• Votre ESP32 reçoit la demande et divise la valeur pour chaque paramètre de couleur.
• Ensuite, il envoie un signal PWM avec la valeur correspondante aux GPIO qui contrôlent la LED RVB.

Comment fonctionnent les LED RVB ?
Dans une LED RVB à cathode commune, les trois LED partagent une connexion négative (cathode). Tous les éléments inclus dans le kit sont des LED RVB à cathode commune.Comment créer différentes couleurs ?
Avec une LED RVB, vous pouvez bien sûr produire de la lumière rouge, verte et bleue, et en configurant l'intensité de chaque LED, vous pouvez également produire d'autres couleurs.
Par exempleampPour produire une lumière purement bleue, vous devez régler la LED bleue sur l'intensité la plus élevée et les LED vertes et rouges sur l'intensité la plus faible. Pour une lumière blanche, vous devez régler les trois LED sur l'intensité la plus élevée.
Mélanger les couleurs
Pour produire d'autres couleurs, vous pouvez combiner les trois couleurs dans des intensités différentes. Pour régler l'intensité de chaque LED, vous pouvez utiliser un signal PWM.
Comme les LED sont très proches les unes des autres, nos yeux voient le résultat de la combinaison des couleurs, plutôt que les trois couleurs individuellement.
Pour avoir une idée sur la façon de combiner les couleurs, jetez un œil au tableau suivant.
Il s'agit du nuancier le plus simple, mais il vous donne une idée de son fonctionnement et de la manière de produire différentes couleurs.Pièces requises
Pour ce projet, vous avez besoin des pièces suivantes :

• Carte ESP32 DEVKIT V1
• LED RVB
• 3 résistances de 220 ohms
• Fils de liaison
• Planche à pain

SchématiqueCode
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)

• Installation du module complémentaire ESP32 dans l'IDE Arduino

Après avoir assemblé le circuit, ouvrez le code
Projet_6_RGB_LED_Web_Server.ino dans l'IDE Arduino.
Avant de télécharger le code, n'oubliez pas d'insérer vos identifiants réseau afin que l'ESP puisse se connecter à votre réseau local.Comment fonctionne le code
Le croquis ESP32 utilise la bibliothèque WiFi.h.Les lignes suivantes définissent des variables de chaîne pour contenir les paramètres R, G et B de la demande.Les quatre variables suivantes sont utilisées pour décoder la requête HTTP ultérieurement.Créez trois variables pour les GPIO qui contrôleront les paramètres R, G et B de la bande. Dans ce cas, nous utilisons GPIO 13, GPIO 12 et GPIO 14.Ces GPIO doivent générer des signaux PWM, nous devons donc d'abord configurer les propriétés PWM. Réglez la fréquence du signal PWM sur 5000 XNUMX Hz. Ensuite, associez un canal PWM à chaque couleurEt enfin, définissez la résolution des canaux PWM sur 8 bitsDans le setup(), attribuez les propriétés PWM aux canaux PWMConnectez les canaux PWM aux GPIO correspondantsLa section de code suivante affiche le sélecteur de couleurs dans votre web page et fait une demande en fonction de la couleur que vous avez choisie.Lorsque vous choisissez une couleur, vous recevez une demande avec le format suivant.

Nous devons donc diviser cette chaîne pour obtenir les paramètres R, G et B. Les paramètres sont enregistrés dans les variables redString, greenString et blueString et peuvent avoir des valeurs comprises entre 0 et 255.Pour contrôler la bande avec l'ESP32, utilisez la fonction ledcWrite() pour générer des signaux PWM avec les valeurs décodées à partir du HTTP demande.Note: en savoir plus sur PWM avec ESP32 : Projet 3 ESP32 PWM (sortie analogique)
Pour contrôler la bande avec l'ESP8266, il suffit d'utiliser
la fonction analogWrite() pour générer des signaux PWM avec les valeurs décodées à partir de la requête HTTP.
analogWrite(redPin, redString.toInt());
analogWrite(pinvert, chaîne verte.toInt());
analogWrite(bluePin, blueString.toInt())
Étant donné que nous obtenons les valeurs dans une variable de chaîne, nous devons les convertir en entiers à l’aide de la méthode toInt().
Démonstration
Après avoir inséré vos informations d'identification réseau, sélectionnez la bonne carte et le bon port COM et téléchargez le code sur votre ESP32. Étapes de référence de téléchargement du code.
Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115200 XNUMX et appuyez sur le bouton ESP Enable/Reset. Vous devriez obtenir l'adresse IP de la carte.Ouvrez votre navigateur et saisissez l'adresse IP de l'ESP. Utilisez maintenant le sélecteur de couleurs pour choisir une couleur pour la LED RVB.
Ensuite, vous devez appuyer sur le bouton « Changer de couleur » pour que la couleur prenne effet.Pour éteindre la LED RVB, sélectionnez la couleur noire.
Les couleurs les plus fortes (en haut du sélecteur de couleurs) sont celles qui produiront de meilleurs résultats.

Projet 7 Relais ESP32 Web Serveur

L'utilisation d'un relais avec l'ESP32 est un excellent moyen de contrôler à distance les appareils électroménagers à courant alternatif. Ce tutoriel explique comment contrôler un module relais avec l'ESP32.
Nous verrons comment fonctionne un module de relais, comment connecter le relais à l'ESP32 et construire un web serveur pour contrôler un relais à distance.
Présentation des relais
Un relais est un interrupteur à commande électrique et comme tout autre interrupteur, il peut être allumé ou éteint, laissant passer le courant ou non. Il peut être contrôlé avec une faible tensiontages, comme le 3.3 V fourni par les GPIO ESP32 et nous permet de contrôler les hauts volumestagcomme 12V, 24V ou tension secteurtage (230 V en Europe et 120 V aux États-Unis).Sur le côté gauche, il y a deux jeux de trois prises pour connecter des appareils à haute tension.tages, et les broches sur le côté droit (faible volumetage) connectez-vous aux GPIO ESP32.
Vol secteurtage ConnexionsLe module relais présenté sur la photo précédente possède deux connecteurs, chacun avec trois prises : commun (COM), normalement fermé (NC) et normalement ouvert (NO).

• COM : connectez le courant que vous souhaitez contrôler (vol secteurtaget).
• NC (Normalement Fermé) : la configuration normalement fermée est utilisée lorsque vous souhaitez que le relais soit fermé par défaut. Les broches NC sont connectées aux broches COM, ce qui signifie que le courant circule à moins que vous n'envoyiez un signal de l'ESP32 au module relais pour ouvrir le circuit et arrêter le flux de courant.
• NON (Normalement Ouvert) : la configuration normalement ouverte fonctionne dans l'autre sens : il n'y a pas de connexion entre les broches NO et COM, donc le circuit est coupé à moins que vous n'envoyiez un signal depuis l'ESP32 pour fermer le circuit.

Broches de contrôleLe faible voltagLe côté est doté d'un ensemble de quatre broches et d'un ensemble de trois broches. Le premier ensemble est composé de VCC et GND pour alimenter le module, et de l'entrée 1 (IN1) et de l'entrée 2 (IN2) pour contrôler respectivement les relais inférieur et supérieur.
Si votre module relais ne possède qu'un seul canal, vous n'aurez qu'une seule broche IN. Si vous avez quatre canaux, vous aurez quatre broches IN, et ainsi de suite.
Le signal que vous envoyez aux broches IN détermine si le relais est actif ou non. Le relais est déclenché lorsque l'entrée descend en dessous d'environ 2 V. Cela signifie que vous aurez les scénarios suivants :

• Configuration Normalement Fermée (NF) :
• Signal HAUT – le courant circule
• Signal FAIBLE – le courant ne circule pas
• Configuration normalement ouverte (NO) :
• Signal HAUT – le courant ne circule pas
• Signal FAIBLE – courant circulant

Vous devez utiliser une configuration normalement fermée lorsque le courant doit circuler la plupart du temps et que vous ne souhaitez l'arrêter qu'occasionnellement.
Utilisez une configuration normalement ouverte lorsque vous souhaitez que le courant circule occasionnellement (par exempleample, allume toutamp occasionnellement).
Sélection de l'alimentation électriqueLe deuxième ensemble de broches se compose des broches GND, VCC et JD-VCC.
La broche JD-VCC alimente l'électroaimant du relais. Notez que le module est doté d'un capuchon de cavalier reliant les broches VCC et JD-VCC ; celui illustré ici est jaune, mais le vôtre peut être d'une couleur différente.
Avec le cavalier en place, les broches VCC et JD-VCC sont connectées. Cela signifie que l'électroaimant du relais est directement alimenté par la broche d'alimentation ESP32, de sorte que le module relais et les circuits ESP32 ne sont pas physiquement isolés les uns des autres.
Sans le capuchon de cavalier, vous devez fournir une source d'alimentation indépendante pour alimenter l'électroaimant du relais via la broche JD-VCC. Cette configuration isole physiquement les relais de l'ESP32 grâce à l'optocoupleur intégré du module, ce qui évite d'endommager l'ESP32 en cas de pics électriques.
SchématiqueAvertissement: Utilisation de haut voltagLes alimentations électriques peuvent provoquer des blessures graves.
Par conséquent, des LED de 5 mm sont utilisées à la place de LED à haut volume d'alimentation.tagampoules dans l'expérience. Si vous n'êtes pas familier avec le vol du secteurtagDemandez à quelqu'un de vous aider. Lors de la programmation de l'ESP ou du câblage de votre circuit, assurez-vous que tout est déconnecté du secteur.tage.Installation de la bibliothèque pour ESP32
Pour construire ceci web serveur, nous utilisons ESPAsyncWebBibliothèque serveur et bibliothèque AsyncTCP.
Installation de l'ESPAsyncWebBibliothèque du serveur
Suivez les étapes suivantes pour installer le ESPAsyncWebServeur bibliothèque:

1. Cliquez ici pour télécharger l'ESPAsyncWebBibliothèque du serveur. Vous devriez avoir
   un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir ESPAsyncWebDossier maître du serveur
3. Renommez votre dossier depuis ESPAsyncWebServeur maître vers ESPAsyncWebServeur
4. Déplacez l'ESPAsyncWebDossier du serveur vers votre dossier de bibliothèques d'installation Arduino IDE

Alternativement, dans votre IDE Arduino, vous pouvez aller dans Sketch > Inclure
Bibliothèque > Ajouter une bibliothèque .ZIP… et sélectionnez la bibliothèque que vous venez de télécharger.
Installation de la bibliothèque AsyncTCP pour ESP32
Le ESPAsyncWebServeur la bibliothèque nécessite la TCP asynchrone Bibliothèque pour travailler. Suivre
les prochaines étapes pour installer cette bibliothèque :

1. Cliquez ici pour télécharger la bibliothèque AsyncTCP. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier AsyncTCP-master
   1. Renommez votre dossier de AsyncTCP-master en AsyncTCP
   3. Déplacez le dossier AsyncTCP vers le dossier des bibliothèques d'installation de votre IDE Arduino
   4. Enfin, rouvrez votre IDE Arduino

Alternativement, dans votre IDE Arduino, vous pouvez aller dans Sketch > Inclure
Bibliothèque > Ajouter une bibliothèque .ZIP… et sélectionnez la bibliothèque que vous venez de télécharger.
Code
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Après avoir installé les bibliothèques requises, ouvrez le code Project_7_ESP32_Relay_Web_Server.ino dans l'IDE Arduino.
Avant de télécharger le code, n'oubliez pas d'insérer vos identifiants réseau afin que l'ESP puisse se connecter à votre réseau local.Démonstration
Après avoir effectué les modifications nécessaires, téléchargez le code sur votre ESP32. Étapes de référence de téléchargement du code.
Ouvrez le moniteur série à un débit en bauds de 115200 et appuyez sur le bouton ESP32 EN pour obtenir son adresse IP. Ensuite, ouvrez un navigateur sur votre réseau local et saisissez l'adresse IP ESP32 pour accéder au web serveur.
Ouvrez le moniteur série à un débit en bauds de 115200 et appuyez sur le bouton ESP32 EN pour obtenir son adresse IP. Ensuite, ouvrez un navigateur sur votre réseau local et saisissez l'adresse IP ESP32 pour accéder au web serveur.Note: Votre navigateur et ESP32 doivent être connectés au même réseau local.
Vous devriez obtenir quelque chose comme suit avec deux boutons selon le nombre de relais que vous avez défini dans votre code.Vous pouvez désormais utiliser les boutons pour contrôler vos relais à l'aide de votre smartphone.

Projet_8_Synchronisation_de_l'état_de_sortie_ Web_Serveur

Ce projet montre comment contrôler les sorties ESP32 ou ESP8266 à l'aide d'un web serveur et un bouton physique simultanément. L'état de sortie est mis à jour sur le web page qu'elle soit modifiée via un bouton physique ou web serveur.
Surplomberview
Jetons un rapide coup d’œil au fonctionnement du projet.L'ESP32 ou l'ESP8266 héberge un web serveur qui permet de contrôler l’état d’une sortie ;

• L'état de sortie actuel est affiché sur l' web serveur;
• L'ESP est également connecté à un bouton-poussoir physique qui contrôle la même sortie ;
• Si vous modifiez l'état de sortie à l'aide du bouton-poussoir physique, son état actuel est également mis à jour sur le web serveur.

En résumé, ce projet vous permet de contrôler la même sortie à l'aide d'un web serveur et un bouton-poussoir simultanément. Chaque fois que l'état de sortie change, le web le serveur est mis à jour.
Pièces requises
Voici une liste des pièces dont vous avez besoin pour construire le circuit :

• Carte ESP32 DEVKIT V1
• DEL 5 mm
• Résistance 220Ohm
• Pushbutton
• Résistance 10 XNUMX ohms
• Planche à pain
• Fils de liaison

SchématiqueInstallation de la bibliothèque pour ESP32
Pour construire ceci web serveur, nous utilisons ESPAsyncWebBibliothèque de serveur et bibliothèque AsyncTCP. (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation de l'ESPAsyncWebBibliothèque du serveur
Suivez les étapes suivantes pour installer ESPAsyncWebBibliothèque du serveur :

1. Cliquez ici pour télécharger l'ESPAsyncWebBibliothèque du serveur. Vous devriez avoir
   un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir ESPAsyncWebDossier maître du serveur
3. Renommez votre dossier depuis ESPAsyncWebServeur maître vers ESPAsyncWebServeur
4. Déplacez l'ESPAsyncWebDossier du serveur vers votre dossier de bibliothèques d'installation Arduino IDE
   Alternativement, dans votre IDE Arduino, vous pouvez aller dans Sketch > Inclure
   Bibliothèque > Ajouter une bibliothèque .ZIP… et sélectionnez la bibliothèque que vous venez de télécharger.

Installation de la bibliothèque AsyncTCP pour ESP32
L'ESPAsyncWebLa bibliothèque du serveur nécessite la bibliothèque AsyncTCP pour fonctionner. Suivez les étapes suivantes pour installer cette bibliothèque :

1. Cliquez ici pour télécharger la bibliothèque AsyncTCP. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier AsyncTCP-master
3. Renommez votre dossier de AsyncTCP-master en AsyncTCP
4. Déplacez le dossier AsyncTCP vers le dossier des bibliothèques d'installation de votre IDE Arduino
5. Enfin, rouvrez votre IDE Arduino
   Alternativement, dans votre IDE Arduino, vous pouvez aller dans Sketch > Inclure
   Bibliothèque > Ajouter une bibliothèque .ZIP… et sélectionnez la bibliothèque que vous venez de télécharger.

Code
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Après avoir installé les bibliothèques requises, ouvrez le code
Projet_8_Synchronisation_de_l'état_de_sortie_Web_Server.ino dans l'IDE Arduino.
Avant de télécharger le code, n'oubliez pas d'insérer vos identifiants réseau afin que l'ESP puisse se connecter à votre réseau local.

Comment fonctionne le code

État du bouton et état de sortie
La variable ledState contient l'état de sortie de la LED. Par défaut, lorsque la web le serveur démarre, il est BAS.

Les buttonState et lastButtonState sont utilisés pour détecter si le bouton-poussoir a été appuyé ou non.Bouton (web serveur)
Nous n'avons pas inclus le HTML pour créer le bouton sur la variable index_html.
C'est parce que nous voulons pouvoir le changer en fonction de l'état actuel de la LED qui peut également être modifié avec le bouton-poussoir.
Nous avons donc créé un espace réservé pour le bouton %BUTTONPLACEHOLDER% qui sera remplacé par du texte HTML pour créer le bouton plus tard dans le code (cela se fait dans la fonction processor()).processeur()
La fonction processor() remplace tous les espaces réservés du texte HTML par des valeurs réelles. Tout d'abord, elle vérifie si les textes HTML contiennent des
espaces réservés %BUTTONPLACEHOLDER%.Ensuite, appelez la fonction outputState() qui renvoie l'état de sortie actuel. Nous l'enregistrons dans la variable outputStateValue.Après cela, utilisez cette valeur pour créer le texte HTML pour afficher le bouton avec le bon état :Requête HTTP GET pour modifier l'état de sortie (JavaScript)
Lorsque vous appuyez sur le bouton, la fonction toggleCheckbox() est appelée. Cette fonction fera une demande sur différents URLs pour allumer ou éteindre la LED.Pour allumer la LED, il fait une requête sur le /update?state=1 URL:Sinon, il fait une requête sur le /update?state=0 URL.
Requête HTTP GET pour mettre à jour l'état (JavaScript)
Pour maintenir l'état de sortie à jour sur le web serveur, nous appelons la fonction suivante qui fait une nouvelle requête sur le /state URL chaque seconde.Traiter les demandes
Ensuite, nous devons gérer ce qui se passe lorsque l'ESP32 ou l'ESP8266 reçoit des requêtes sur ces URLs.
Lorsqu'une requête est reçue sur la racine /URL, nous envoyons la page HTML ainsi que le processeur.Les lignes suivantes vérifient si vous avez reçu une demande sur /update?state=1 ou /update?state=0 URL et modifie le ledState en conséquence.Lorsqu'une demande est reçue sur le /state URL, nous envoyons l'état de sortie actuel :boucle()
Dans la boucle (), nous neutralisons le bouton-poussoir et allumons ou éteignons la LED en fonction de la valeur de ledState variable.Démonstration
Téléchargez le code sur votre carte ESP32. Étapes de référence de téléchargement du code.
Ensuite, ouvrez le moniteur série à un débit en bauds de 115200 XNUMX. Appuyez sur le bouton EN/RST intégré pour obtenir son adresse IP.Ouvrez un navigateur sur votre réseau local et saisissez l'adresse IP ESP. Vous devriez avoir accès à l' web serveur comme indiqué ci-dessous.
Note: Votre navigateur et ESP32 doivent être connectés au même réseau local.Vous pouvez basculer le bouton sur le web serveur pour allumer la LED.Vous pouvez également contrôler la même LED avec le bouton poussoir physique. Son état sera toujours mis à jour automatiquement sur le web serveur.

Projet 9 ESP32 DHT11 Web Serveur

Dans ce projet, vous apprendrez à construire un ESP32 asynchrone web serveur avec le DHT11 qui affiche la température et l'humidité à l'aide d'Arduino IDE.
Prérequis
Le web le serveur que nous allons construire met à jour les lectures automatiquement sans qu'il soit nécessaire de les actualiser. web page.
Avec ce projet, vous apprendrez :

• Comment lire la température et l’humidité des capteurs DHT ;
• Construire un asynchrone web serveur utilisant le ESPAsyncWebBibliothèque du serveur;
• Mettez à jour automatiquement les lectures du capteur sans avoir besoin d'actualiser le web page.

Asynchrone Web Serveur
Pour construire le web serveur, nous utiliserons le ESPAsyncWebBibliothèque du serveur qui fournit un moyen simple de créer un asynchrone web serveur. Construire un serveur asynchrone web le serveur a plusieurs avantagestagcomme mentionné dans la page GitHub de la bibliothèque, par exemple :

• « Gérer plusieurs connexions en même temps » ;
• « Lorsque vous envoyez la réponse, vous êtes immédiatement prêt à gérer d’autres connexions pendant que le serveur se charge d’envoyer la réponse en arrière-plan » ;
• « Moteur de traitement de modèles simple pour gérer les modèles » ;

Pièces requises
Pour réaliser ce tutoriel, vous avez besoin des éléments suivants :

• Carte de développement ESP32
• Module DHT11
• Planche à pain
• Fils de liaison

SchématiqueInstallation des bibliothèques
Vous devez installer quelques bibliothèques pour ce projet :

• Le DHT et le Capteur unifié Adafruit Bibliothèques de pilotes à lire à partir du capteur DHT.
• ESPAsyncWebServeur et TCP asynchrone bibliothèques pour construire l'asynchrone web serveur.
  Suivez les instructions suivantes pour installer ces bibliothèques :

Installation de la bibliothèque de capteurs DHT
Pour lire à partir du capteur DHT à l'aide d'Arduino IDE, vous devez installer le Bibliothèque de capteurs DHTSuivez les étapes suivantes pour installer la bibliothèque.

1. Cliquez ici pour télécharger la bibliothèque du capteur DHT. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier DHT-sensor-library-master
3. Renommez votre dossier de DHT-sensor-library-master en DHT_sensor
4. Déplacez le dossier DHT_sensor vers le dossier des bibliothèques d'installation de votre IDE Arduino
5. Enfin, rouvrez votre IDE Arduino

Installation du pilote de capteur unifié Adafruit
Vous devez également installer le Bibliothèque de pilotes de capteurs unifiés Adafruit pour travailler avec le capteur DHT. Suivez les étapes suivantes pour installer la bibliothèque.

1. Cliquez ici pour télécharger la bibliothèque Adafruit Unified Sensor. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier Adafruit_sensor-master
3. Renommez votre dossier de Adafruit_sensor-master en Adafruit_sensor
4. Déplacez le dossier Adafruit_sensor vers le dossier des bibliothèques d'installation de votre IDE Arduino
5. Enfin, rouvrez votre IDE Arduino

Installation de l'ESPAsyncWebBibliothèque du serveur

Suivez les étapes suivantes pour installer le ESPAsyncWebServeur bibliothèque:

1. Cliquez ici pour télécharger l'ESPAsyncWebBibliothèque du serveur. Vous devriez avoir
   un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez
   obtenir ESPAsyncWebDossier maître du serveur
3. Renommez votre dossier depuis ESPAsyncWebServeur maître vers ESPAsyncWebServeur
4. Déplacez l'ESPAsyncWebDossier du serveur vers votre dossier de bibliothèques d'installation Arduino IDE

Installation de la bibliothèque TCP asynchrone pour ESP32
Le ESPAsyncWebServeur la bibliothèque nécessite la TCP asynchrone bibliothèque pour fonctionner. Suivez les étapes suivantes pour installer cette bibliothèque :

1. Cliquez ici pour télécharger la bibliothèque AsyncTCP. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
2. Décompressez le dossier .zip et vous devriez obtenir le dossier AsyncTCP-master
3. Renommez votre dossier de AsyncTCP-master en AsyncTCP
4. Déplacez le dossier AsyncTCP vers le dossier des bibliothèques d'installation de votre IDE Arduino
5. Enfin, rouvrez votre IDE Arduino

Code
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE Arduino
Après avoir installé les bibliothèques requises, ouvrez le code
Projet_9_ESP32_DHT11_Web_Server.ino dans l'IDE Arduino.
Avant de télécharger le code, n'oubliez pas d'insérer vos identifiants réseau afin que l'ESP puisse se connecter à votre réseau local.Comment fonctionne le code
Dans les paragraphes suivants, nous expliquerons comment fonctionne le code. Continuez à lire si vous souhaitez en savoir plus ou passez à la section Démonstration pour voir le résultat final.
Importer des bibliothèques
Tout d'abord, importez les bibliothèques requises. Le WiFi, ESPAsyncWebLe serveur et ESPAsyncTCP sont nécessaires pour construire le web serveur. Les bibliothèques Adafruit_Sensor et DHT sont nécessaires pour lire les capteurs DHT11 ou DHT22.Définition des variables
Définissez le GPIO auquel la broche de données DHT est connectée. Dans ce cas, elle est connectée au GPIO 4.Ensuite, sélectionnez le type de capteur DHT que vous utilisez. Dans notre example, on utilise le DHT22. Si tu utilises un autre type, il te suffit de décommenter ton capteur et de commenter tous les autres.

Instanciez un objet DHT avec le type et le code PIN que nous avons définis précédemment.Créer un asynchroneWebObjet serveur sur le port 80.Lire les fonctions de température et d'humidité
Nous avons créé deux fonctions : une pour lire la température Nous avons créé deux fonctions : une pour lire la température (readDHTTemperature()) et l'autre pour lire l'humidité (readDHTHumidity()).Obtenir des lectures de capteurs est aussi simple que d'utiliser les méthodes readTemperature() et readHumidity() sur l'objet dht.Nous avons également une condition qui renvoie deux tirets (–) au cas où le capteur ne parvient pas à obtenir les lectures.Les valeurs sont renvoyées sous forme de chaîne. Pour convertir un float en chaîne, utilisez la fonction String()Par défaut, nous lisons la température en degrés Celsius. Pour obtenir la température en degrés Fahrenheit, commentez la température en degrés Celsius et supprimez le commentaire de la température en degrés Fahrenheit, de sorte à obtenir le résultat suivant :Télécharger le code
Téléchargez maintenant le code sur votre ESP32. Assurez-vous d'avoir sélectionné la bonne carte et le bon port COM. Étapes de référence pour télécharger le code.
Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115200 32. Appuyez sur le bouton de réinitialisation de l'ESP32. L'adresse IP de l'ESPXNUMX doit être imprimée dans le port série. moniteur.Démonstration
Ouvrez un navigateur et saisissez l'adresse IP de l'ESP32. Votre web le serveur doit afficher les dernières lectures des capteurs.
Note: Votre navigateur et ESP32 doivent être connectés au même réseau local.
Notez que les relevés de température et d'humidité sont mis à jour automatiquement sans qu'il soit nécessaire d'actualiser le web page.

Projet_10_Ecran_OLED_ESP32

Ce projet montre comment utiliser l'écran OLED SSD0.96 de 1306 pouce avec ESP32 à l'aide d'Arduino IDE.
Présentation de l'écran OLED de 0.96 pouce
Le Écran OLED que nous utiliserons dans ce tutoriel est le modèle SSD1306 : un écran monochrome de 0.96 pouce avec 128×64 pixels comme indiqué dans la figure suivante.L'écran OLED ne nécessite pas de rétroéclairage, ce qui permet d'obtenir un contraste très agréable dans les environnements sombres. De plus, ses pixels ne consomment de l'énergie que lorsqu'ils sont allumés, ce qui fait que l'écran OLED consomme moins d'énergie que les autres écrans.
Comme l'écran OLED utilise le protocole de communication I2C, le câblage est très simple. Vous pouvez utiliser le tableau suivant comme référence.

Broche OLED	ESP32
Vin	3.3V
Terre	Terre
SCL	GPIO22
Adventiste du Septième Jour	GPIO21

SchématiqueInstallation de la bibliothèque OLED SSD1306 – ESP32
Il existe plusieurs bibliothèques disponibles pour contrôler l'écran OLED avec l'ESP32.
Dans ce tutoriel, nous utiliserons deux bibliothèques Adafruit : Bibliothèque Adafruit_SSD1306 et Bibliothèque Adafruit_GFX.
Suivez les étapes suivantes pour installer ces bibliothèques.

1. Ouvrez votre IDE Arduino et accédez à Sketch > Inclure la bibliothèque > Gérer les bibliothèques. Le gestionnaire de bibliothèques devrait s'ouvrir.
2. Tapez « SSD1306 » dans la zone de recherche et installez la bibliothèque SSD1306 d’Adafruit.
3. Après avoir installé la bibliothèque SSD1306 d’Adafruit, tapez « GFX » dans la zone de recherche et installez la bibliothèque.
4. Après avoir installé les bibliothèques, redémarrez votre Arduino IDE.

Code
Après avoir installé les bibliothèques requises, ouvrez le projet_10_ESP32_OLED_Display.ino dans Arduino IDE. code
Nous allons programmer l'ESP32 à l'aide d'Arduino IDE, alors assurez-vous d'avoir installé le module complémentaire ESP32 avant de continuer : (Si vous avez déjà effectué cette étape, vous pouvez passer à l'étape suivante.)
Installation du module complémentaire ESP32 dans l'IDE ArduinoComment fonctionne le code
Importer des bibliothèques
Tout d'abord, vous devez importer les bibliothèques nécessaires. La bibliothèque Wire pour utiliser I2C et les bibliothèques Adafruit pour écrire sur l'écran : Adafruit_GFX et Adafruit_SSD1306.Initialiser l'écran OLED
Ensuite, vous définissez la largeur et la hauteur de votre OLED. Dans cet exempleampnous utilisons un écran OLED 128 × 64. Si vous utilisez d'autres tailles, vous pouvez les modifier dans les variables SCREEN_WIDTH et SCREEN_HEIGHT.Ensuite, initialisez un objet d'affichage avec la largeur et la hauteur définies précédemment avec le protocole de communication I2C (&Wire).Le paramètre (-1) signifie que votre écran OLED n'a pas de broche RESET. Si votre écran OLED possède une broche RESET, elle doit être connectée à un GPIO. Dans ce cas, vous devez transmettre le numéro GPIO en tant que paramètre.
Dans le setup(), initialisez le moniteur série à un débit en bauds de 115200 XNUMX à des fins de débogage.Initialisez l’écran OLED avec la méthode begin() comme suit :Cet extrait imprime également un message sur le moniteur série, au cas où nous ne serions pas en mesure de nous connecter à l'écran.

Si vous utilisez un autre écran OLED, vous devrez peut-être modifier l'adresse OLED. Dans notre cas, l'adresse est 0x3C.Après avoir initialisé l'écran, ajoutez un délai de deux secondes, afin que l'OLED ait suffisamment de temps pour s'initialiser avant d'écrire du texte :Affichage clair, définition de la taille de la police, de la couleur et écriture du texte
Après avoir initialisé l'affichage, effacez le tampon d'affichage avec la méthode clearDisplay() :

Avant d'écrire du texte, vous devez définir la taille du texte, la couleur et l'emplacement où le texte sera affiché dans l'OLED.
Définissez la taille de la police à l’aide de la méthode setTextSize() :Définissez la couleur de la police avec la méthode setTextColor() :
BLANC définit une police blanche et un arrière-plan noir.
Définissez la position où le texte commence à l'aide de la méthode setCursor(x,y). Dans ce cas, nous définissons le texte pour qu'il commence aux coordonnées (0,0) – dans le coin supérieur gauche.Enfin, vous pouvez envoyer le texte à l'écran en utilisant la méthode println(), comme suitEnsuite, vous devez appeler la méthode display() pour afficher réellement le texte à l’écran.

La bibliothèque OLED Adafruit fournit des méthodes utiles pour faire défiler facilement le texte.

• startscrollright(0x00, 0x0F) : faire défiler le texte de gauche à droite
• startscrollleft(0x00, 0x0F) : faire défiler le texte de droite à gauche
• startscrolldiagright(0x00, 0x07) : faire défiler le texte du coin inférieur gauche vers le coin supérieur droit startscrolldiagleft(0x00, 0x07) : faire défiler le texte du coin inférieur droit vers le coin supérieur gauche

Télécharger le code
Maintenant, téléchargez le code sur votre ESP32. Étapes de référence de téléchargement du code.
Après avoir téléchargé le code, l'OLED affichera du texte défilant.

Documents / Ressources

Kit de démarrage de base LAFVIN ESP32 [pdf] Manuel d'instructions Kit de démarrage de base ESP32, ESP32, Kit de démarrage de base, Kit de démarrage

Références

• Manuel d'utilisation