Explorons dans ce tutoriel, l'ESP32, la fantastique nouvelle carte de kit de développement pour l'utilisation de l'IoT. Cette carte, développée par Espressif, devrait être le successeur du NodeMCU, en raison de son prix bas et de ses excellentes fonctionnalités.

Mais il est également important de noter que PAS TOUTES les bibliothèques ou fonctions que vous avez l'habitude de travailler avec ESP8266 et / ou Arduino ne sont pas encore fonctionnelles sur cette nouvelle carte. Ce sera probablement bientôt, alors vérifiez-le régulièrement sur ESP 32 Forum WebPage.

Ici, nous allons apprendre à programmer l'ESP32 sur Arduino IDE, en explorant ses fonctions et bibliothèques les plus courantes, en soulignant certaines des différences importantes et les nouvelles fonctionnalités introduites avec cette excellente puce.

En bref, nous explorerons:

• Sortie numérique: clignoter une LED
• Entrée numérique: lecture d'un capteur tactile
• Entrée analogique: lecture d'une tension variable à partir d'un potentiomètre
• Sortie analogique: contrôle de la luminosité d'une LED
• Sortie analogique: contrôle d'une position de servo
• Lecture des données de température / humidité avec un capteur numérique
• Se connecter à Internet et obtenir l'heure locale
• Recevoir des données d'une simple page Web locale, allumer / éteindre une LED
• Transmission de données à une simple page Web locale

Étape 1: Les principales caractéristiques de l'ESP32

L'ESP32 est une carte de moins de 10 USD avec de grands avantages par rapport aux cartes IoT similaires sur le marché.

Cette carte dispose d'un microprocesseur à double traitement qui aide beaucoup, car lorsqu'un processeur gère la communication, l'autre est en charge du contrôle des E / S, par exemple. Cette fonctionnalité empêchera certains problèmes qui se produisent avec ESP8266, où le processeur unique doit cesser de contrôler les E / S lors de la gestion avec Comm. En outre, l'ESP32 a intégré WIFI, BLUETOOTH, DAC, plusieurs ADC (pas seulement un comme l'ESP8266), des capteurs tactiles capacitifs, etc. (jetez un œil au schéma ci-dessus). Et la bonne nouvelle est que la consommation d'énergie est presque la même que l'ESP8266.

Ci-dessous un tableau qui peut nous montrer ses principales caractéristiques et différences par rapport au ESP8266:

Voyons plus en détail ses principales propriétés:

Principales caractéristiques:

• Microcontrôleur Tensilica LX6 dual core 240 MHz avec 600 DMIPS
• SRAM 520 Ko intégré
• Émetteur-récepteur Wi-Fi 802.11 b / g / n HT40 intégré, bande de base, pile et LwIP
• Bluetooth double mode intégré (classique et BLE)
• Flash de 16 Mo, mappé en mémoire à l'espace de code du processeur
• Tension de fonctionnement de 2, 3 V à 3, 6 V
• -40 ° C à + 125 ° C de température de fonctionnement
• Antenne PCB intégrée / connecteur IPEX pour antenne externe

Capteurs:

• Amplificateur analogique à très faible bruit
• Capteur à effet Hall
• 10x interfaces tactiles capacitives
• Oscillateur à cristal 32 kHz

34 x GPIO:

• 3 x UART, y compris le contrôle de flux matériel
• 3 x SPI
• 2 x I2S
• 18 x canaux d'entrée ADC
• 2 x DAC
• 2 x I2C
• Entrée / sortie PWM / timer disponible sur chaque broche GPIO
• Interface de débogage OpenOCD avec tampon TRAX de 32 Ko
• Maître / esclave SDIO 50 MHz
• Prend en charge le flash SPI externe jusqu'à 16 Mo
• Prise en charge de l'interface de carte SD

Concernant la sécurité:

• WEP, WPA / WPA2 PSK / Enterprise
• Cryptage accéléré matériel: AES / SHA2 / Cryptographie à courbe elliptique / RSA-4096

Performance:

• Prise en charge des modes renifleur, Station, SoftAP et Wi-Fi direct
• Débit de données maximal de 150 HT40, 72 HT20, 54 et 11
• Puissance de transmission maximale de 19, 5, 16, 5, 15, 5
• Sensibilité minimale du récepteur de -97 dBm
• Débit soutenu à 135 Mbps UDP
• Consommation électrique de 5 μA en veille profonde

Étape 2: BoM - Nomenclature

• Kit de développement ESP32: carte de développement ESP32 (8, 52 USD)
• Micro Servo: Mini Servo TowerPro SG90 9G (3, 80 $ US)
• Capteur de température / hum DHT22 / AM2302 Capteur numérique de température et d'humidité (US $ 9.99)
• LED
• 2 x résistances: 330 ohms et 10K ohms
• Potentiomètre: 10K ohm
• Protoboards

Étape 3: Installation de l'ESP32 Arduino IDE

Nous utiliserons l'IDE Arduino pour programmer notre ESP32, de la même manière que nous le faisons avec la famille ESP8266.

Installer les pilotes:

Il est important que vous ayez installé sur votre ordinateur le pilote CP210x USB vers UART mis à jour. Entrez dans ce lien: usb-to-uart-bridge-vcp-drivers et installez le pilote approprié pour votre système d'exploitation.

Installer la bibliothèque:

La nouveauté ici est qu'Expressif lui-même dans son GitHub, nous donnera les instructions appropriées pour l'installation de la bibliothèque: arduino-esp32. Suivez les instructions de votre système d'exploitation. Dans mon cas (MacOS), l'installation est très simple:

Ouvrez Terminal et exécutez la commande suivante (copier-> coller et appuyez sur Entrée):

 mkdir -p ~ / Documents / Arduino / hardware / espressif && \ cd ~ / Documents / Arduino / hardware / espressif && \ git clone //github.com/espressif/arduino-esp32.git esp32 && \ cd esp32 / tools / &&& \ python get.py 

Après cela, redémarrez Arduino IDE et c'est fait! Vous devez voir plusieurs panneaux dans le menu "OUTILS". Sélectionnez ce qui vous convient. En général, le MODULE ESP32 "générique" fonctionne correctement.

Lorsque vous ouvrez l'Arduino IDE pour la première fois, vous remarquerez que la vitesse de téléchargement par défaut est de 921 600 bauds. Cela peut provoquer une instabilité. Changez-le en 115 200 bauds !

Étape 4: Bonjour tout le monde! Clignotant une LED

Comme d'habitude, la première chose à faire lorsque nous commençons à explorer un nouveau matériel est de faire clignoter une LED.

Allez dans le menu Exemples dans l'EDI et ouvrez l'esquisse Blink.

L'ESP32 DevKit, a une LED intégrée qui est connectée à son GPIO 02. Il est important de vérifier si " LED_BUILTIN " est automatiquement reconnu par IDE. Sinon, vous devez ajouter pour coder la ligne:

 int LED_BUILTIN = 2; 

Chaque carte ESP32 a une LED interne connectée à un GPIO différent

 / * ESP 32 Blink Allume une LED pendant une seconde, puis s'éteint pendant une seconde, à plusieurs reprises. L'ESP32 a une LED bleue interne à D2 (GPIO 02) * / int LED_BUILTIN = 2; void setup () {pinMode (LED_BUILTIN, OUTPUT); } boucle vide () {digitalWrite (LED_BUILTIN, HIGH); // allume la LED (HIGH est le niveau de tension) delay (1000); // attend une seconde digitalWrite (LED_BUILTIN, LOW); // éteint la LED en retardant la tension (1000); // attend une seconde} 

Sous la LED interne clignotante (notez la lumière bleue) avec une externe connectée au GPIO 2:

Il existe plusieurs cartes différentes avec différentes cartes de broches sur le marché. Le schéma ci-dessus montre la carte que j'utilise. Vous pouvez le trouver ici: / ESP32-Development-Board

Parfait! Donc, DigitalWrite () fonctionne parfaitement, de la même manière avec ESP8266 et Arduino. BTW, DigitalRead () fonctionne également de la même manière pour lire une entrée numérique, comme un bouton-poussoir par exemple.

Étape 5: Le capteur tactile

Passons à une nouvelle fonctionnalité intéressante, le capteur tactile !

L'ESP32 dispose de 10 capteurs tactiles capacitifs internes. Vous pouvez l'utiliser comme boutons par exemple.

Ces capteurs sont connectés à plusieurs 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

Pour les lire, vous devez utiliser la fonction: touchRead (Touch Pin #);

Par exemple, pour lire le capteur tactile 0 (T0), vous devez faire quelque chose comme:

 valeur int = touchRead (4); 

Créons un code, où si nous touchons le capteur T0 (GPIO4), la LED sera allumée.

Utilisez le moniteur série pour vérifier les valeurs lues par le capteur et réglez correctement le code.

Ci-dessous le code complet:

 / ************************************************* **** * Test tactile ESP32 et LED Ctrl * Broche tactile ==> Touch0 est T0 qui est sur GPIO 4 (D4). * Broche LED ==> D2 * * MJRoBot.org 6Sept17 ************************************* **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; void setup () {Serial.begin (115200); retard (1000); // donnez-moi le temps de faire apparaître le moniteur série Serial.println ("ESP32 Touch Test"); pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, LOW); } boucle vide () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // obtient la valeur en utilisant T0 if (touch_value <50) {digitalWrite (LED_PIN, HIGH); } else {digitalWrite (LED_PIN, LOW); } délai (1000); } 

Et ci-dessous le ESP32 fonctionne:

Étape 6: entrée analogique

Voyons maintenant comment entrer des signaux de valeurs analogiques.

Il y a au total 18 x 12 bits canaux d'entrée ADC, contre seulement 1 X 10 bits ADC sur NodeMCU.

Canal GPIO ADC

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

Pour lire l'entrée analogique, vous aurez la même chose que pour Arduino et ESP8266:

 int analog_value = analogRead (36); 

Il est très important de noter que les ADC ESP32 ont une résolution de 12 bits (contre 10 bits sur ESP8266 et Arduino), donc la plage totale de lecture des ADC passe à 4095 (au lieu de 1027 sur Arduinos et ESP8266) lorsqu'un maximum de 3, 3 V est appliqué à ses entrées.

Pour l'entrée, utilisons un potentiomètre de 10K ohms, en le connectant à 3, 3V et GND. Utilisons sa sortie variable comme entrée pour les broches ESP32 ADC. Le diagramme ci-dessus montre le potentiomètre connecté au GPIO 36 qui est le canal 0 de l'ADC1. Essayez également d'autres entrées sur votre carte.

Exécutez le code simple ci-dessous:

 / ************************************************* ***** * Test d'entrée analogique ESP32 * Entrée analogique: broche ADC_1_0 ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ******************************************** ********* / // Entrée analogique #define ANALOG_PIN_0 36 int analog_value = 0; void setup () {Serial.begin (115200); retard (1000); // donnez-moi le temps de faire apparaître le moniteur série Serial.println ("ESP32 Analog IN Test"); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (valeur_analogue); retard (500); } 

Tournez votre potentiomètre et observez sur IDE Serial Monitor les mesures allant de zéro à 4095.

Étape 7: Gradation d'une LED: sortie analogique à l'aide de PWM

Si nous voulons "Dimmer une LED" sur ESP8266 ou un Arduino, nous pouvons simplement utiliser une commande comme analogWrite (), qui variera la valeur PWM de sa sortie, simulant une valeur analogique. Malheureusement, nous n'avons toujours pas développé ce type de commande pour l'ESP32 sur Arduino IDE. mais la très bonne nouvelle est que les 36 GPIO ESP32 ont tous une capacité PWM, ce qui est génial! Seulement, nous devons utiliser un code plus complexe pour atteindre le même résultat.

Alors, programmons l'un de ces GPIO avec un signal de sortie PWM.

Vous pouvez trouver un très bon tutoriel en détail sur le fonctionnement de PWM sur ce lien: esp32-arduino-led-pwm-fading.

La première chose à penser à un signal PWM à générer est sa fréquence. Nous utiliserons une valeur de 5000 Hz, qui fonctionne bien avec la LED. Nous devons également spécifier le canal LED PWM et la résolution du rapport cyclique PWM, en bits. On peut choisir un canal de 0 à 15 et une résolution entre 1 et 16 bits. Nous utiliserons le canal 0 et une résolution de 8 bits.

 int freq = 5000; int ledChannel = 0; résolution int = 8; 

Utilisons GPIO2, où nous avons notre LED externe attachée (et la LED interne).

 #define LED_PIN 2 

Ces paramètres doivent être définis pendant la phase de configuration (), en utilisant les fonctions ci-dessous:

 void setup () {ledcSetup (ledChannel, freq, resolution); ledcAttachPin (LED_PIN, ledChannel); } 

Pour allumer la LED avec une luminosité spécifique, il faut définir le "rapport cyclique".

Par exemple, pour éteindre la LED, le rapport cyclique doit être nul et la fonction ledcWrite (ledChannel, dutyCycle) utilisée pour envoyer la valeur via un canal PWM spécifique:

 int dutyCycle = 0; ledcWrite (ledChannel, dutyCycle); 

Différentes valeurs de la variable dutyCycle allumeront la LED avec une luminosité différente. cette variable, dutyCycle, variera de 0 à 255, une fois que la résolution utilisée sera de 8 bits.

Nous pouvons utiliser le potentiomètre (connecté à la variable analog_value ) pour configurer manuellement la variable dutyCycle, mais une fois que leur plage de valeurs est différente, utilisons une fonction de carte pour faire correspondre l'entrée et la sortie:

 dutyCycle = map (valeur_analogue, 0, 4095, 0, 255); 

Ci-dessous le code complet:

 ************************************************** *** * Test d'entrée / sortie analogique ESP32 * Entrée analogique: broche ADC_1_0 ==> GPIO36 (VP). * Broche LED PWM ==> GPIO 02 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Entrée analogique #define ANALOG_PIN_0 36 int analog_value = 0; // PMW LED #define LED_PIN 2 int freq = 5000; int ledChannel = 0; résolution int = 8; int dutyCycle = 0; void setup () {Serial.begin (115200); retard (1000); // donnez-moi le temps de faire apparaître le moniteur série Serial.println ("ESP32 Analog IN / OUT Test"); ledcSetup (ledChannel, freq, résolution); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (valeur_analogue); dutyCycle = map (valeur_analogue, 0, 4095, 0, 255); ledcWrite (ledChannel, dutyCycle); retard (500); } 

C'est ça!

Étape 8: servocommande

Contrôlons un servomoteur en utilisant la capacité PWM de notre ESP32. Le code sera essentiellement le même que celui utilisé pour contrôler la luminosité de la LED.

Tout d'abord, il est important de se rappeler que la fréquence de travail avec un Micro Servo est de 50 Hz, nous devons donc changer le paramètre de fréquence à 50 (au lieu de 5 000 utilisé avec LED). Nous devons également spécifier le canal LED PWM et la résolution du rapport cyclique PWM, en bits. Nous utiliserons à nouveau le canal 0 et une résolution de 8 bits.

 int freq = 50; canal int = 0; résolution int = 8; 

Le servo sera connecté au GPIO 5 (voir schéma électrique ci-dessus).

 #define SERVO_PIN 5 

Comme pour les LED, ces paramètres doivent être définis pendant la phase de configuration (), en utilisant les fonctions ci-dessous:

 void setup () {ledcSetup (canal, fréquence, résolution); ledcAttachPin (SERVO_PIN, canal); } 

Pour positionner le servo sur un angle spécifique, il faut définir le "rapport cyclique" (voir le schéma ci-dessus).

Par exemple, pour positionner le servo à environ 90 degrés, le rapport cyclique doit être d'environ 21 et la fonction ledcWrite (ledChannel, dutyCycle) doit être utilisée pour envoyer la valeur via le canal PWM:

 int dutyCycle = 21; ledcWrite (canal, dutyCycle); 

Différentes valeurs de la variable dutyCycle positionneront le servo avec différents angles. Cette variable, dutyCycle, devrait varier de 10 à 32 (cette plage a été obtenue manuellement).

Comme pour la LED, le potentiomètre (connecté à la variable analog_value ) peut être utilisé pour configurer manuellement la variable dutyCycle et ainsi, changer la position du servo. Une fois que leurs plages de valeurs sont différentes, utilisons une fonction de mappage pour faire correspondre l'entrée et la sortie:

 dutyCycle = map (analog_value, 0, 4095, 10, 33); 

Ci-dessous le code complet:

 / ************************************************* **** * Servocommande ESP32 * Entrée analogique: broche ADC_1_0 ==> GPIO36 (VP). * Broche SERVO PWM ==> GPIO 05 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Entrée analogique #define ANALOG_PIN_0 36 int analog_value = 0; // PMW SERVO #define SERVO_PIN 5 int freq = 50; canal int = 0; résolution int = 8; int dutyCycle = 21; void setup () {Serial.begin (115200); retard (1000); // donnez-moi le temps de faire apparaître le moniteur série Serial.println ("ESP32 Servo Control"); ledcSetup (canal, fréquence, résolution); ledcAttachPin (SERVO_PIN, canal); ledcWrite (canal, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Cycle d'utilisation ==>"); Serial.println (dutyCycle); dutyCycle = map (analog_value, 0, 4095, 10, 33); ledcWrite (canal, dutyCycle); retard (50); } 

Maintenant, nous pouvons travailler avec le capteur à ultrasons au-dessus du servo et construire un radar IoT!. Mais ce sera un autre tutoriel! ;-)

Étape 9: Connexion à Internet: horodatage local

Après avoir testé certaines des capacités numériques / analogiques et d'entrée / sortie de GPIO, connectons notre ESP32 sur Internet!

Avec la famille ESP8266, nous utilisions la bibliothèque esp8266wifi.h pour cela. Avec l'ESP32, la bibliothèque à utiliser sera:

Un exemple très simple serait de programmer notre carte pour capturer à partir d'Internet l'heure locale. C'est une très bonne fonctionnalité à avoir sur les projets. Le code ci-dessous le fera pour nous:

 / ************************************************* ************* * Horodatage local avec ESP32 * Développé par Marcelo Rovai - 8 septembre 2017 ********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // En secondes #define NTP_INTERVAL 60 * 1000 // En millisecondes #define NTP_ADDRESS "europe.pool.ntp.org" WiFiUDP ntpUDP; NTPClient timeClient (ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL); void setup () {Serial.begin (115200); timeClient.begin (); } 

Vous pouvez voir sur Serial monitor l'heure locale horodatée.

Étape 10: Serveur WiFi simple

Testons maintenant notre ESP32 comme un simple serveur WiFi.

• Ouvrez le menu EXEMPLES sur votre Arduino IDE et obtenez l'esquisse ESP32 WiFi / SimpleWiFiServer.ino:

À propos de ce programme:

Voyant du serveur Web WiFi clignotant

• Créé pour arduino 25 novembre 2012 par Tom Igoe
• Porté pour sparkfun esp32 31.01.2017 par Jan Hendrik Berlin

Un serveur Web simple qui vous permet de faire clignoter une LED via le Web. Cette esquisse imprimera l'adresse IP de votre réseau WiFi ESP32 sur le moniteur série. De là, vous pouvez ouvrir cette adresse dans un navigateur Web pour allumer et éteindre la LED sur la broche 5.

Si l'adresse IP de votre carte est par exemple 10.0.1.40 :

• //10.0.1.40/H allume la LED

• //10.0.1.40/L

  éteint la LED

Cet exemple est écrit pour un réseau utilisant le cryptage WPA. Pour WEP ou WPA, modifiez l'appel Wifi.begin () en conséquence.

Circuit: LED attachée à la broche 5

Alors, utilisons le programme sans modifications importantes. Changez la broche LED externe en GPIO5

Bien sûr, si vous préférez changer le code pour GPIO2 sans changer le matériel.

Tout d'abord, entrez vos informations d'identification réseau:

 const char * ssid = "yourssid"; const char * password = "yourpasswd"; 

Et téléchargez-le sur votre ESP32.

La première chose que vous verrez sur votre moniteur série sera l'information que votre ESP32 est connecté et quelle est son adresse IP:

 WiFi connecté. Adresse IP: 10.0.1.40 

Ouvrez votre navigateur préféré en tapant cette adresse IP. Vous obtiendrez une page Web comme celle ci-dessus. Là, vous pouvez allumer ou éteindre la LED à distance.

Étape 11: DHT 22 - Lecture de la température et de l'humidité

Un capteur très utile à utiliser sur les projets IoT est le DHT 11 ou 22. Ils sont très bon marché et faciles à inclure dans vos projets.

Tout d'abord, vous devez avoir la bibliothèque Adafrut installée sur votre IDE. Allez sur leur GitHub et téléchargez la version mise à jour de cette bibliothèque: DHT-sensor-library

Décompressez le fichier, renommez-le en DHT et déplacez le dossier complet dans votre répertoire de bibliothèque Arduino

Lorsque j'ai utilisé pour la première fois, j'ai reçu un message:

erreur fatale: Adafruit_Sensor.h: aucun fichier ou répertoire de ce type

Après quelques recherches, j'ai constaté qu'il était également nécessaire d'avoir également installé la bibliothèque de capteurs unifiés Adafruit . Donc, je l'ai fait depuis Arduino IDE Library Manager (voir l'image ci-dessus). Après cela, tout a bien fonctionné, comme nous le faisons avec Arduino et NodeMCU.

Faisons quelques tests avec ce capteur. Suivez le schéma électrique ci-dessus et installez le DHT22 comme indiqué (en regardant le capteur avec la "grille" face à vous, comptez les 4 pieds de gauche à droite):

1. Broche VCC ==> 3, 3 V
2. Pin Data ==> GPIO 23
3. NC
4. PIN GND ==> GND

Connectez également une résistance de 10K ohms entre VCC et Data.

C'est ça!

Vous pouvez utiliser l'exemple d'esquisse "DHT tester.ino" qu'il est inclus dans la bibliothèque, ou faire le vôtre.

J'ai écrit un code simple pour tester le capteur comme indiqué ci-dessous:

 / ************************************************* **** * Lecture ESPT DHT * Entrée DHT: ==> GPIO23. * * MJRoBot.org 9Sept17 ******************************************** ********* / / * DHT * / #inclut "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float localHum = 0; float localTemp = 0; void setup () {Serial.begin (115200); retard (1000); // donnez-moi le temps de faire apparaître le moniteur série Serial.println (""); Serial.println ("ESP32 DHT température et humidité"); Serial.println (""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); retard (2000); } / ************************************************ *** * Obtenez les données de température / ronflement intérieur **************************************** ************ / void getDHT () {float tempIni = localTemp; float humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Vérifiez si les lectures ont échoué et quittez tôt (pour réessayer). {localTemp = tempIni; localHum = humIni; revenir; }} 

Vous pouvez voir le résultat sur PrintScreen ci-dessus du moniteur série.

Étape 12: envoi et réception de données à partir d'une page Web locale

Revoir ce que nous avons couvert jusqu'à présent dans ce tutoriel:

• Sortie numérique: clignoter une LED
• Entrée numérique: lecture d'un capteur tactile
• Entrée analogique: lecture d'une tension variable à partir d'un potentiomètre
• Sortie analogique: contrôle de la luminosité d'une LED
• Sortie analogique: contrôle d'une position de servo
• Lecture des données de température / humidité avec un capteur numérique
• Se connecter à Internet et obtenir l'heure locale
• Création d'une page Web simple pour allumer / éteindre une LED (réception de données)

Nous réalisons que nous devons encore essayer d'envoyer des données vers une page Web. Alors faisons-le!

Nous prendrons les données générées par notre capteur DHT et la valeur analogique fournie par le potentiomètre et les enverrons à la page Web créée pour contrôler les LED.

Je suis parti du code SimpleWiFiServer utilisé à l'étape 10 et j'ai ajouté les lignes de code pertinentes pour obtenir le potentiomètre et les données DHT.

Notez que j'ai replacé la LED sur GPIO 2 comme vous pouvez le voir sur le schéma électrique.

Téléchargez le code complet depuis mon GitHub: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Notez que j'ai mieux organisé le code et maintenant, la boucle () est seulement:

 boucle vide () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); } 

La nouveauté ici est la fonction "WiFiLocalWebPageCtrl ()". Mais, c'est exactement la fonction setup () d'origine utilisée sur SimpleWebServer. Ce que j'ai inclus dans cette fonction, c'est ce qui devrait apparaître dans la page Web (voir l'écran d'impression ci-dessus pour la page Web).

 // le contenu de la réponse HTTP suit l'en-tête: // WiFiLocalWebPageCtrl (); client.print ("La température est maintenant:"); client.print (localTemp); client.print ("oC 
"); client.print (" L'humidité est maintenant: "); client.print (localHum); client.print ("% 
"); client.print (" 
"); client.print (" Données analogiques: "); client.print (valeur_analogue); client.print (" 
"); client.print (" 
"); client.print (" Cliquez ici pour allumer la LED. 
"); client.print (" Cliquez ici pour éteindre la LED. " 
"); 

Notez que la température, l'humidité et les valeurs analogiques seront mises à jour chaque fois que vous cliquez sur les liens utilisés pour le contrôle des LED ou lorsque vous actualisez la page.

Étape 13: Conclusion

Nous pourrions continuer encore et encore ici, mais nous ne couvririons jamais toutes les fonctions ou potentialités de l'ESP32. Il reste beaucoup à explorer avec ce formidable appareil IoT et dans mon prochain tutoriel, vous apprendrez comment ajouter un écran OLED sur votre ESP32:

Écran ESP32 et OLED: horloge Internet - DHT22

Nous reviendrons bientôt avec de nouveaux tutoriels ESP32!

Comme toujours, j'espère que ce projet pourra aider les autres à trouver leur chemin dans le monde passionnant de l'électronique, de la robotique et de l'IoT!

Veuillez visiter mon GitHub pour les fichiers mis à jour: Jouer avec ESP32 et Arduino IDE

Pour plus de projets, veuillez visiter mon blog: MJRoBot.org

Saludos du sud du monde!

Rendez-vous à mon prochain instructable!

Merci,

Marcelo