IOT Made Simple: spelen met de ESP32 op Arduino IDE

Laten we in deze tutorial de ESP32 verkennen, het fantastische nieuwere Development Kit-bord voor IoT-gebruik. Dit bord, ontwikkeld door Espressif, zou de opvolger van de NodeMCU moeten zijn, vanwege de lage prijs en geweldige functies.

Maar het is ook belangrijk om erop te wijzen dat NIET ALLE bibliotheken of functies die u gewend bent om met ESP8266 en / of Arduino te werken, nog functioneel zijn op dit nieuwe bord. Dit zal waarschijnlijk binnenkort zijn, dus controleer het regelmatig op ESP 32 Forum WebPage.

Hier zullen we leren hoe we de ESP32 op Arduino IDE kunnen programmeren, de meest voorkomende functies en bibliotheken verkennen, enkele van de belangrijke verschillen en nieuwe functies die met deze geweldige chip zijn geïntroduceerd, aanwijzen.

Kortom, we onderzoeken:

  • Digitale uitgang: een LED knippert
  • Digitale ingang: een aanraaksensor lezen
  • Analoge ingang: aflezen van een variabele spanning van een potentiometer
  • Analoge uitgang: controle van een LED-helderheid
  • Analoge uitgang: controle van een servopositie
  • Temperatuur- / vochtigheidsgegevens aflezen met een digitale sensor
  • Verbinding maken met internet en lokale tijd ophalen
  • Gegevens ontvangen van een eenvoudige lokale webpagina, een LED in- / uitschakelen
  • Gegevens verzenden naar een eenvoudige lokale webpagina

Stap 1: De belangrijkste kenmerken van ESP32

De ESP32 is een board van minder dan US $ 10 met grote voordelen ten opzichte van vergelijkbare IoT-boards op de markt.

Dit bord heeft een dubbel verwerkte microprocessor die veel helpt, want wanneer de ene processor de communicatie afhandelt, heeft de andere bijvoorbeeld de leiding over I / O-besturing. Deze functie voorkomt enkele problemen die zich voordoen met ESP8266, waarbij de enige CPU de I / O's niet meer hoeft te besturen wanneer deze wordt afgehandeld met Comm. Bovendien heeft de ESP32 geïntegreerde WIFI, BLUETOOTH, DAC, verschillende ADC (niet alleen één als de ESP8266), capacitieve aanraaksensoren, enz. (Bekijk het blokschema hierboven). En het goede nieuws is dat het stroomverbruik bijna hetzelfde is als ESP8266.

Hieronder een grafiek die ons de belangrijkste kenmerken en verschillen kan laten zien in vergelijking met ESP8266:

Laten we de belangrijkste eigenschappen in meer detail bekijken:

Belangrijkste kenmerken:

  • 240 MHz dual-core Tensilica LX6-microcontroller met 600 DMIPS
  • Geïntegreerde 520 KB SRAM
  • Geïntegreerde 802.11 b / g / n HT40 Wi-Fi-transceiver, basisband, stack en LwIP
  • Geïntegreerde dual-mode Bluetooth (klassiek en BLE)
  • 16 MB flash, geheugen toegewezen aan de CPU-coderuimte
  • Bedrijfsspanning van 2, 3 V tot 3, 6 V
  • -40 ° C tot + 125 ° C bedrijfstemperatuur
  • Ingebouwde PCB-antenne / IPEX-connector voor externe antenne

Sensoren:

  • Ultra-low noise analoge versterker
  • Hall-sensor
  • 10x capacitieve aanraakinterfaces
  • 32 kHz kristaloscillator

34 x GPIO:

  • 3 x UART's, inclusief hardwarestroomregeling
  • 3 x SPI
  • 2 x I2S
  • 18 x ADC-ingangskanalen
  • 2 x DAC
  • 2 x I2C
  • PWM / timer input / output beschikbaar op elke GPIO-pin
  • OpenOCD debug-interface met 32 ​​kB TRAX-buffer
  • SDIO master / slave 50 MHz
  • Ondersteunt externe SPI-flash tot 16 MB
  • Ondersteuning voor SD-kaartinterface

Beveiliging gerelateerd:

  • WEP, WPA / WPA2 PSK / Enterprise
  • Hardwareversnelde codering: AES / SHA2 / Elliptical Curve Cryptography / RSA-4096

Prestatie:

  • Ondersteunt sniffer, Station, SoftAP en Wi-Fi Direct-modus
  • Maximale gegevenssnelheid van 150 mailbeveiliging HT40, 72 mailbeveiliging HT20, 54 mailbeveiliging en 11 mailbeveiliging
  • Maximaal zendvermogen van 19, 5, 16, 5, 15, 5
  • Minimale ontvangergevoeligheid van -97 dBm
  • 135 Mbps UDP aanhoudende verwerkingscapaciteit
  • 5 μA stroomverbruik in diepe slaap

Stap 2: BoM - Stuklijst

  • ESP32 Dev Kit: ESP32 Development Board (US $ 8, 52)
  • Micro Servo: TowerPro SG90 9G Mini Servo (US $ 3, 80)
  • Temp / Hum-sensor DHT22 / AM2302 Digitale temperatuur- en vochtigheidssensor (US $ 9, 99)
  • LED
  • 2 x weerstanden: 330 ohm en 10K ohm
  • Potentiometer: 10K ohm
  • Protoboards

Stap 3: ESP32 Arduino IDE-installatie

We zullen de Arduino IDE gebruiken om onze ESP32 te programmeren, op dezelfde manier als bij de ESP8266-familie.

Stuurprogramma's installeren:

Het is belangrijk dat u op uw computer de bijgewerkte CP210x USB naar UART-driver heeft geïnstalleerd. Voer deze link in: usb-naar-uart-bridge-vcp-stuurprogramma's en installeer het juiste stuurprogramma voor uw besturingssysteem.

Bibliotheek installeren:

De nieuwigheid hier is dat Expressif zelf in zijn GitHub ons de juiste aanwijzingen geeft voor de installatie van de bibliotheek: arduino-esp32. Volg de instructies voor uw besturingssysteem. In mijn geval (MacOS) is de installatie heel eenvoudig:

Open Terminal en voer de volgende opdracht uit (kopiëren-> plakken en druk op enter):

 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 

Start daarna Arduino IDE opnieuw op en het is klaar! Je moet verschillende borden zien in het menu "GEREEDSCHAP". Selecteer de juiste voor jou. Over het algemeen werkt de "generieke" ESP32 DEV-MODULE prima.

Wanneer je de Arduino IDE voor het eerst opent, zul je merken dat de standaard uploadsnelheid 921.600 baud is. Dit kan instabiliteit veroorzaken. Verander het in 115.200 bauds !

Stap 4: Hallo wereld! Knippert een LED

Zoals gewoonlijk is het eerste dat we moeten doen wanneer we een nieuwe HW gaan verkennen, het knipperen van een LED.

Ga naar het voorbeeldenmenu in de IDE en open de Blink-schets.

De ESP32 DevKit heeft een ingebouwde LED die is aangesloten op de GPIO 02. Het is belangrijk om te controleren of " LED_BUILTIN " automatisch wordt herkend door IDE. Zo niet, dan moet u de regel toevoegen aan de code:

 int LED_BUILTIN = 2; 
Elk ESP32-bord heeft een interne LED die is aangesloten op een andere GPIO
 / * ESP 32 Knippert Schakelt een LED één seconde aan en vervolgens herhaaldelijk één seconde uit. De ESP32 heeft een interne blauwe LED op D2 (GPIO 02) * / int LED_BUILTIN = 2; ongeldige setup () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, HIGH); // zet de LED aan (HOOG is het spanningsniveau) vertraging (1000); // wacht op een tweede digitalWrite (LED_BUILTIN, LOW); // zet de LED uit door de spanning LAGE vertraging (1000) te maken; // wacht even} 

Hieronder knippert de interne LED (let op het blauwe lampje) samen met een externe die is aangesloten op GPIO 2:

Er zijn verschillende borden met verschillende pinkaarten op de markt. Het bovenstaande diagram toont het bord dat ik gebruik. Je kunt het hier vinden: / ESP32-Development-Board

Perfect! Dus DigitalWrite () werkt perfect, op dezelfde manier met ESP8266 en Arduino. Trouwens, DigitalRead () werkt ook op dezelfde manier om een ​​digitale ingang te lezen, zoals een drukknop bijvoorbeeld.

Stap 5: de aanraaksensor

Laten we naar een nieuwe coole functie springen, de aanraaksensor !

De ESP32 heeft 10 interne capacitieve aanraaksensoren. Je kunt het bijvoorbeeld als knoppen gebruiken.

Die sensoren zijn verbonden met verschillende GPIO's:

  • 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

Om ze te kunnen lezen moet je de functie gebruiken: touchRead (Touch Pin #);

Om bijvoorbeeld de aanraaksensor 0 (T0) te lezen, moet u iets doen als:

 int waarde = touchRead (4); 

Laten we een code maken, waarbij als we de sensor T0 (GPIO4) aanraken, de LED gaat branden.

Gebruik de seriële monitor om de waarden te controleren die door de sensor worden gelezen en pas de code correct aan.

Hieronder de volledige code:

 / ************************************************** **** * ESP32 Touch Test en LED Ctrl * Touch pin ==> Touch0 is T0 op GPIO 4 (D4). * LED pin ==> D2 * * MJRoBot.org 6Sept17 ************************************** **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; ongeldige setup () {Serial.begin (115200); vertraging (1000); // geef me tijd om seriële monitor Serial.println ("ESP32 Touch Test") te openen; pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, LOW); } ongeldige lus () {touch_value = touchRead (TOUTCH_PIN); Serial.println (aanraakwaarde); // waarde ophalen met T0 if (touch_value <50) {digitalWrite (LED_PIN, HIGH); } anders {digitalWrite (LED_PIN, LOW); } vertraging (1000); } 

En onder de ESP32 werkt:

Stap 6: Analoge ingang

Laten we nu testen hoe we analoge waardesignalen kunnen invoeren.

Er zijn in totaal 18 x 12 bits ADC-ingangskanalen, tegenover slechts 1 x 10 bits ADC op NodeMCU.

GPIO ADC-kanaal

  • 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

Om de analoge ingang te lezen, zult u hetzelfde doen als met Arduino en ESP8266:

 int analog_value = analogRead (36); 

Het is erg belangrijk om op te merken dat de ESP32 ADC's 12 bits resolutie hebben (versus 10 bits op ESP8266 en Arduino), dus het totale bereik van ADC's lezen gaat naar 4095 (in plaats van 1, 027 op Arduinos en ESP8266) wanneer een maximum van 3, 3 V wordt toegepast op zijn input.

Voor invoer gebruiken we een 10K ohm-potentiometer, die deze aansluit op 3.3V en GND. Laten we de variabele uitvoer gebruiken als invoer voor ESP32 ADC-pinnen. Het bovenstaande diagram toont de potentiometer die is aangesloten op GPIO 36, dat is het ADC1-kanaal 0. Probeer ook andere ingangen op uw bord.

Voer de onderstaande eenvoudige code uit:

 / ************************************************** ***** * ESP32 Analoge ingangstest * Analoge ingang: ADC_1_0 pin ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ********************************************* ********* / // Analoge ingang # definieer ANALOG_PIN_0 36 int analog_value = 0; ongeldige setup () {Serial.begin (115200); vertraging (1000); // geef me tijd om seriële monitor Serial.println ("ESP32 Analog IN Test") te openen; } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); vertraging (500); } 

Draai je potentiometer en observeer op IDE Serial Monitor de metingen gaande van nul tot 4.095.

Stap 7: Dimmen van een LED: Analoge output met PWM

Als we een LED "willen dimmen" op ESP8266 of een Arduino, kunnen we eenvoudig een commando gebruiken zoals analogWrite (), dat de PWM-waarde van zijn output zal variëren, waarbij een analoge waarde wordt gesimuleerd. Helaas hebben we nog steeds niet zo'n soort commando ontwikkeld voor de ESP32 op Arduino IDE. maar het goede nieuws is dat alle 36 ESP32 GPIO's een PWM-mogelijkheid hebben, wat geweldig is! Alleen moeten we complexere code gebruiken om hetzelfde resultaat te bereiken.

Laten we dus een van die GPIO's programmeren met een PWM-uitgangssignaal.

Je kunt een zeer goede tutorial vinden in details over hoe PWM werkt op deze link: esp32-arduino-led-pwm-fading.

Het eerste dat u moet bedenken over een PWM-signaal dat moet worden gegenereerd, is de frequentie. We gebruiken een waarde van 5000 Hz, dat werkt prima met de led. We moeten ook het LED PWM-kanaal en de resolutie van de PWM-duty cycle in bits specificeren. We kunnen een kanaal kiezen van 0 tot 15 en een resolutie tussen 1 en 16 bits. We gebruiken kanaal 0 en een resolutie van 8 bits.

 int freq = 5000; int ledChannel = 0; int resolutie = 8; 

Laten we GPIO2 gebruiken, waar we onze externe LED hebben aangesloten (en de interne).

 #define LED_PIN 2 

Die parameters moeten worden gedefinieerd tijdens de setup () -fase, met behulp van de onderstaande functies:

 leegte setup () {ledcSetup (ledChannel, freq, resolutie); ledcAttachPin (LED_PIN, ledChannel); } 

Om de LED met een specifieke helderheid in te schakelen, moeten we de "duty cycle" definiëren.

Om bijvoorbeeld de LED uit te schakelen, moet de werkcyclus nul zijn en moet de functie ledcWrite (ledChannel, dutyCycle) worden gebruikt om de waarde via een specifiek PWM-kanaal te verzenden:

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

Verschillende waarden van de dutyCycle-variabele zullen de LED met verschillende helderheid inschakelen. deze variabele, dutyCycle, zal variëren van 0 tot 255, zodra de gebruikte resolutie 8 bits is.

We kunnen de Potentiometer (verbonden met analog_value- variabele) gebruiken om de dutyCycle-variabele handmatig in te stellen, maar zodra hun waardenbereik anders is, laten we een kaartfunctie gebruiken om input en output te matchen:

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

Hieronder de volledige code:

 *************************************************** *** * ESP32 Analoge ingang / uitgangstest * Analoge ingang: ADC_1_0 pin ==> GPIO36 (VP). * PWM LED pin ==> GPIO 02 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Analoge ingang # definiëren ANALOG_PIN_0 36 int analog_value = 0; // PMW LED #define LED_PIN 2 int freq = 5000; int ledChannel = 0; int resolutie = 8; int dutyCycle = 0; ongeldige setup () {Serial.begin (115200); vertraging (1000); // geef me tijd om seriële monitor Serial.println ("ESP32 Analog IN / OUT Test") te openen; ledcSetup (ledChannel, freq, resolutie); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); dutyCycle = map (analog_value, 0, 4095, 0, 255); ledcWrite (ledChannel, dutyCycle); vertraging (500); } 

Dat is het!

Stap 8: Servobesturing

Laten we een servomotor besturen met behulp van de PWM-capaciteit van onze ESP32. De code is in feite dezelfde als die werd gebruikt om de helderheid van de LED te regelen.

Ten eerste is het belangrijk om te onthouden dat de frequentie om met een Micro Servo te werken 50 Hz is, dus we moeten de frequentieparameter wijzigen in 50 (in plaats van 5.000 gebruikt met LED). We moeten ook het LED PWM-kanaal en de resolutie van de PWM-duty cycle in bits specificeren. We zullen weer kanaal 0 en een resolutie van 8 bits gebruiken.

 int freq = 50; int kanaal = 0; int resolutie = 8; 

De Servo wordt aangesloten op GPIO 5 (zie hierboven elektrisch schema).

 # definieer SERVO_PIN 5 

Hetzelfde als bij LED, deze parameters moeten worden gedefinieerd tijdens de setup () fase, met behulp van onderstaande functies:

 ongeldige setup () {ledcSetup (kanaal, freq, resolutie); ledcAttachPin (SERVO_PIN, kanaal); } 

Om de servo onder een bepaalde hoek te plaatsen, moeten we de "inschakelduur" definiëren (zie het bovenstaande diagram).

Om bijvoorbeeld de servo ongeveer 90 graden te positioneren, moet de inschakelduur ongeveer 21 zijn en de functie ledcWrite (ledChannel, dutyCycle) moet worden gebruikt om de waarde door het PWM-kanaal te sturen:

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

Verschillende waarden van de dutyCycle-variabele positioneren de servo met verschillende hoeken. Deze variabele, dutyCycle, moet variëren van 10 tot 32 (dit bereik is handmatig opgehaald).

Hetzelfde als we deden met de LED, de Potentiometer (verbonden met analog_value variabele) kan worden gebruikt om de dutyCycle-variabele handmatig in te stellen en zo de servopositie te veranderen. Zodra hun waardenbereik anders is, laten we een kaartfunctie gebruiken om invoer en uitvoer te matchen:

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

Hieronder de volledige code:

 / ************************************************** **** * ESP32 Servobesturing * Analoge ingang: ADC_1_0 pin ==> GPIO36 (VP). * PWM SERVO pin ==> GPIO 05 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Analoge ingang # definiëren ANALOG_PIN_0 36 int analog_value = 0; // PMW SERVO #define SERVO_PIN 5 int freq = 50; int kanaal = 0; int resolutie = 8; int dutyCycle = 21; ongeldige setup () {Serial.begin (115200); vertraging (1000); // geef me de tijd om Serial.println ("ESP32 Servo Control") op te roepen; ledcSetup (kanaal, freq, resolutie); ledcAttachPin (SERVO_PIN, kanaal); ledcWrite (kanaal, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Duty Cycle ==>"); Serial.println (dutyCycle); dutyCycle = map (analog_value, 0, 4095, 10, 33); ledcWrite (kanaal, dutyCycle); vertraging (50); } 

Nu kunnen we met de ultrasone sensor bovenop de servo werken en een IoT-radar bouwen !. Maar dit wordt weer een tutorial! ;-)

Stap 9: Verbinding maken met internet: lokale tijdstempel

Na het testen van enkele van de GPIO digitale / analoge en input / output-mogelijkheden, laten we onze ESP32 op het internet aansluiten!

Met de ESP8266-familie gebruikten we daarvoor de bibliotheek esp8266wifi.h . Met de ESP32 zal de te gebruiken bibliotheek zijn:

Een heel eenvoudig voorbeeld is het programmeren van ons bord om de lokale tijd van internet vast te leggen. Dit is een zeer goede functie om bij de hand te hebben bij projecten. De onderstaande code zal het voor ons doen:

 / ************************************************** ************* * Lokale tijdstempel met ESP32 * Ontwikkeld door Marcelo Rovai - 8 september 2017 *********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // In seconden #define NTP_INTERVAL 60 * 1000 // In miliseconden #define NTP_ADDRESS "europe.pool.ntp.org" WiFiUDP ntpUDP; NTPClient timeClient (ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL); ongeldige setup () {Serial.begin (115200); timeClient.begin (); } 

U kunt op Seriële monitor de lokale tijd zien die wordt afgestempeld.

Stap 10: Simple WiFi Server

Laten we nu onze ESP32 testen als een eenvoudige WiFi-server.

  • Open het VOORBEELDEN-menu op uw Arduino IDE en ontvang de ESP32 WiFi / SimpleWiFiServer.ino-schets:

Over dit programma:

Lampje WiFi-webserver knippert

  • Gemaakt voor arduino 25 november 2012 door Tom Igoe
  • Gepoort voor sparkfun esp32 31.01.2017 door Jan Hendrik Berlin

Een eenvoudige webserver waarmee je via internet een led kunt laten knipperen. Deze schets print het IP-adres van uw ESP32 WiFi-netwerk naar de seriële monitor. Van daaruit kunt u dat adres openen in een webbrowser om de LED op pin 5 in en uit te schakelen.

Als het IP-adres van uw board bijvoorbeeld 10.0.1.40 is :

  • //10.0.1.40/H zet de LED aan
  • //10.0.1.40/L

    schakelt de LED uit

Dit voorbeeld is geschreven voor een netwerk dat WPA-codering gebruikt. Wijzig voor WEP of WPA de oproep Wifi.begin () dienovereenkomstig.

Circuit: LED bevestigd aan pin 5

Laten we het programma dus zonder noemenswaardige wijzigingen gebruiken. Wijzig de externe LED-pin in GPIO5

Natuurlijk, als u liever de code voor GPIO2 wijzigt zonder de HW te wijzigen.

Voer eerst uw netwerkreferenties in:

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

En upload het op uw ESP32.

Het eerste dat u op uw seriële monitor ziet, is de informatie dat uw ESP32 is aangesloten en wat het IP-adres is:

 WiFi verbonden. IP-adres: 10.0.1.40 

Open uw favoriete browser en typ dit IP-adres. U krijgt een webpagina zoals hierboven. Daar kunt u de LED op afstand in- of uitschakelen.

Stap 11: DHT 22 - Temperatuur en vochtigheid aflezen

Een zeer nuttige sensor voor gebruik bij IoT-projecten is de DHT 11 of 22. Ze zijn erg goedkoop en gemakkelijk op te nemen in uw projecten.

Eerst moet u de Adafrut-bibliotheek op uw IDE hebben geïnstalleerd. Ga naar hun GitHub en download de bijgewerkte versie van deze bibliotheek: DHT-sensor-bibliotheek

Pak het bestand uit, hernoem het naar DHT en verplaats de volledige map naar uw Arduino Library-map

Toen ik de eerste keer gebruikte, kreeg ik een bericht:

fatale fout: Adafruit_Sensor.h: Bestand of map bestaat niet

Na wat graven ontdekte ik dat het ook nodig is om de Adafruit Unified Sensor Library ook te hebben geïnstalleerd. Dus ik deed het vanuit Arduino IDE Library Manager (zie afbeelding hierboven). Daarna werkte alles prima, hetzelfde als wat we doen met Arduino en NodeMCU.

Laten we wat testen doen met deze sensor. Volg het bovenstaande elektrische schema en installeer de DHT22 zoals afgebeeld (kijk naar de sensor met het "raster" naar u toe, tel de 4 poten van links naar rechts):

  1. Pin VCC ==> 3.3V
  2. Pin gegevens ==> GPIO 23
  3. N / C
  4. PIN GND ==> GND

Sluit ook een 10K ohm-weerstand aan tussen VCC en Data.

Dat is het!

U kunt de voorbeeldschets "DHT tester.ino" gebruiken die in de bibliotheek is opgenomen, of u kunt deze zelf maken.

Ik heb een eenvoudige code geschreven om de sensor te testen, zoals hieronder weergegeven:

 / ************************************************** **** * ESP32 DHT-uitlezing * DHT-invoer: ==> GPIO23. * * MJRoBot.org 9 sept17 ********************************************* ********* / / * DHT * / #inclusief "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); zweven localHum = 0; zweven localTemp = 0; ongeldige setup () {Serial.begin (115200); vertraging (1000); // geef me tijd om seriële monitor Serial.println ("") te openen; Serial.println ("ESP32 DHT temperatuur en vochtigheid"); Serial.println (""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); vertraging (2000); } / ************************************************* *** * Haal binnen Temp / Hum gegevens ***************************************** ************ / ongeldig getDHT () {float tempIni = localTemp; zweven humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Controleer of het lezen is mislukt en sluit vroeg af (om het opnieuw te proberen). {localTemp = tempIni; localHum = humIni; terugkeren; }} 

U kunt het resultaat zien op bovenstaande PrintScreen van Serial Monitor.

Stap 12: Gegevens verzenden en ontvangen van een lokale webpagina

Bekijken wat we tot nu toe hebben behandeld in deze tutorial:

  • Digitale uitgang: een LED knippert
  • Digitale ingang: een aanraaksensor lezen
  • Analoge ingang: aflezen van een variabele spanning van een potentiometer
  • Analoge uitgang: controle van een LED-helderheid
  • Analoge uitgang: controle van een servopositie
  • Temperatuur- / vochtigheidsgegevens aflezen met een digitale sensor
  • Verbinding maken met internet en lokale tijd ophalen
  • Een eenvoudige webpagina maken om een ​​LED in / uit te schakelen (gegevens ontvangen)

We beseffen dat we nog steeds moeten proberen om gegevens naar een webpagina te sturen. Dus laten we het doen!

We nemen de gegevens die zijn gegenereerd door onze DHT-sensor en de analoge waarde die wordt geleverd door de potentiometer en sturen deze naar de webpagina die is gemaakt om de LED's te bedienen.

Ik begon met de SimpleWiFiServer-code die in stap 10 werd gebruikt en voegde de relevante coderegels toe om de potentiometer- en DHT-gegevens te krijgen.

Merk op dat ik de LED terug naar GPIO 2 heb verplaatst, zoals je op het elektrische diagram kon zien.

Download de volledige code van mijn GitHub: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Merk op dat ik de code beter heb georganiseerd en nu is de lus () alleen:

 leegte lus () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); } 

De nieuwigheid hier is de functie "WiFiLocalWebPageCtrl ()". Maar dit is precies de oorspronkelijke functie setup () die wordt gebruikt op SimpleWebServer. Wat ik in deze functie heb opgenomen, is wat er op de webpagina moet verschijnen (zie het bovenstaande printscherm voor de webpagina).

 // de inhoud van het HTTP-antwoord volgt de koptekst: // WiFiLocalWebPageCtrl (); client.print ("Temperatuur is nu:"); client.print (localTemp); client.print ("oC 
"); client.print (" Vochtigheid is nu: "); client.print (localHum); client.print ("%
"); client.print ("
"); client.print (" Analog Data: "); client.print (analog_value); client.print ("
"); client.print ("
"); client.print (" Klik hier om de LED in te schakelen.
"); client.print (" Klik hier om de LED uit te schakelen.
");
Houd er rekening mee dat de temperatuur, vochtigheid en analoge waarden worden bijgewerkt telkens wanneer u op de links klikt die worden gebruikt voor LED-besturing of wanneer u de pagina vernieuwt.

Stap 13: Conclusie

We zouden hier door kunnen gaan, maar we zouden nooit alle ESP32-functies of potentialiteit behandelen. Er valt nog veel te ontdekken met dit geweldige IoT-apparaat en in mijn volgende tutorial leer je hoe je een OLED-scherm toevoegt aan je ESP32:

ESP32 en OLED-display: internetklok - DHT22

We komen snel terug met nieuwe ESP32-tutorials!

Zoals altijd hoop ik dat dit project anderen kan helpen hun weg te vinden in de opwindende wereld van elektronica, robotica en IoT!

Bezoek mijn GitHub voor bijgewerkte bestanden: spelen met ESP32 en Arduino IDE

Bezoek mijn blog voor meer projecten: MJRoBot.org

Saludos uit het zuiden van de wereld!

Tot ziens bij mijn volgende instructable!

Dank je,

Marcelo

Verwante Artikelen