Schaltungen

IOT leicht gemacht: Spielen mit dem ESP32 auf Arduino IDE

Lassen Sie uns in diesem Tutorial das ESP32 untersuchen, das fantastische neuere Development Kit-Board für den IoT-Einsatz. Dieses von Espressif entwickelte Board sollte aufgrund seines niedrigen Preises und seiner hervorragenden Funktionen der Nachfolger der NodeMCU sein.

Es ist jedoch auch wichtig darauf hinzuweisen, dass NICHT ALLE Bibliotheken oder Funktionen, die Sie mit ESP8266 und / oder Arduino gewohnt sind, auf dieser neuen Karte noch funktionsfähig sind. Wahrscheinlich wird dies bald geschehen. Überprüfen Sie es daher regelmäßig auf der ESP 32-Forum-Webseite.

Hier erfahren Sie, wie Sie den ESP32 auf Arduino IDE programmieren, die gängigsten Funktionen und Bibliotheken erkunden und einige der wichtigen Unterschiede und neuen Funktionen aufzeigen, die mit diesem großartigen Chip eingeführt wurden.

Kurz gesagt, wir werden untersuchen:

Digitalausgang: Blinkt eine LED
Digitaleingang: Lesen eines Berührungssensors
Analogeingang: Lesen einer variablen Spannung von einem Potentiometer
Analogausgang: Steuerung der LED-Helligkeit
Analogausgang: Steuerung einer Servoposition
Lesen von Temperatur- / Feuchtigkeitsdaten mit einem digitalen Sensor
Verbindung zum Internet herstellen und Ortszeit abrufen
Empfangen von Daten von einer einfachen lokalen Webseite, Ein- und Ausschalten einer LED
Übertragen von Daten auf eine einfache lokale Webseite

Schritt 1: Die Hauptmerkmale des ESP32

Das ESP32 ist ein Board unter 10 US-Dollar mit großen Vorteilen gegenüber ähnlichen IoT-Boards auf dem Markt.

Diese Karte verfügt über einen doppelt verarbeiteten Mikroprozessor, der sehr hilfreich ist, denn wenn ein Prozessor die Kommunikation übernimmt, ist der andere beispielsweise für die E / A-Steuerung verantwortlich. Diese Funktion verhindert einige Probleme, die bei ESP8266 auftreten, bei denen die einzige CPU die Steuerung der E / A nicht mehr benötigt, wenn sie mit Comm verarbeitet wird. Außerdem hat der ESP32 WIFI, BLUETOOTH, DAC, mehrere ADC (nicht nur einen wie der ESP8266), kapazitive Berührungssensoren usw. integriert (siehe obiges Blockdiagramm). Und die gute Nachricht ist, dass der Stromverbrauch fast dem des ESP8266 entspricht.

Unten sehen Sie eine Tabelle, die uns die Hauptmerkmale und Unterschiede im Vergleich zu ESP8266 zeigen kann:

Lassen Sie uns die Haupteigenschaften genauer erläutern:

Hauptmerkmale:

240 MHz Dual Core Tensilica LX6 Mikrocontroller mit 600 DMIPS
Integrierter 520 KB SRAM
Integrierter 802.11 b / g / n HT40 Wi-Fi-Transceiver, Basisband, Stack und LwIP
Integriertes Dual-Mode-Bluetooth (klassisch und BLE)
16 MB Flash, dem CPU-Code-Speicher zugeordnet
Betriebsspannung von 2, 3 V bis 3, 6 V.
-40 ° C bis + 125 ° C Betriebstemperatur
Integrierte PCB-Antenne / IPEX-Anschluss für externe Antenne

Sensoren:

Analoger Verstärker mit extrem geringem Rauschen
Hallsensor
10x kapazitive Touch-Schnittstellen
32 kHz Quarzoszillator

34 x GPIO:

3 x UARTs, einschließlich Hardware-Flusskontrolle
3 x SPI
2 x I2S
18 x ADC-Eingangskanäle
2 x DAC
2 x I2C
PWM / Timer-Ein- / Ausgang an jedem GPIO-Pin verfügbar
OpenOCD-Debug-Schnittstelle mit 32 kB TRAX-Puffer
SDIO Master / Slave 50 MHz
Unterstützt externen SPI-Flash bis zu 16 MB
Unterstützung der SD-Kartenschnittstelle

Sicherheitsrelevant:

WEP, WPA / WPA2 PSK / Enterprise
Hardwarebeschleunigte Verschlüsselung: AES / SHA2 / Elliptical Curve Cryptography / RSA-4096

Performance:

Unterstützt Sniffer-, Station-, SoftAP- und Wi-Fi-Direktmodus
Maximale Datenrate von 150 HT40, 72 HT20, 54 und 11
Maximale Sendeleistung von 19, 5, 16, 5, 15, 5
Minimale Empfängerempfindlichkeit von -97 dBm
UDP mit 135 Mbit / s und anhaltendem Durchsatz
5 μA Stromverbrauch im Tiefschlaf

Schritt 2: Stückliste

ESP32 Dev Kit: ESP32 Development Board (8, 52 US-Dollar)
Mikro-Servo: TowerPro SG90 9G Mini-Servo (US $ 3, 80)
Temperatur- / Brummsensor DHT22 / AM2302 Digitaler Temperatur- und Feuchtigkeitssensor (9, 99 US-Dollar)
LED
2 x Widerstände: 330 Ohm und 10 K Ohm
Potentiometer: 10 kOhm
Protoboards

Schritt 3: Installation der ESP32 Arduino IDE

Wir werden die Arduino IDE verwenden, um unseren ESP32 zu programmieren, genauso wie wir es mit der ESP8266-Familie tun.

Treiber installieren:

Es ist wichtig, dass Sie auf Ihrem Computer den aktualisierten CP210x USB to UART-Treiber installiert haben. Geben Sie in diesen Link Folgendes ein: usb-to-uart-bridge-vcp-drivers und installieren Sie den richtigen Treiber für Ihr Betriebssystem.

Bibliothek installieren:

Die Neuheit hier ist, dass Expressif selbst in seinem GitHub uns die richtigen Anweisungen für die Installation der Bibliothek gibt: arduino-esp32. Befolgen Sie die Anweisungen für Ihr Betriebssystem. In meinem Fall (MacOS) ist die Installation sehr einfach:

Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus (Kopieren-> Einfügen und drücken Sie die Eingabetaste):

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

Starten Sie danach Arduino IDE neu und fertig! Sie müssen mehrere Bretter im Menü "WERKZEUGE" sehen. Wählen Sie das für Sie passende aus. Im Allgemeinen funktioniert das "generische" ESP32 DEV-MODUL einwandfrei.

Wenn Sie die Arduino IDE zum ersten Mal öffnen, werden Sie feststellen, dass die Standard-Upload-Geschwindigkeit 921.600 Bauds beträgt. Dies kann zu Instabilität führen. Ändern Sie es auf 115.200 Bauds !

Schritt 4: Hallo Welt! LED blinkt

Wie üblich ist das erste, was wir tun müssen, wenn wir eine neue HW erkunden, eine LED zu blinken.

Gehen Sie in der IDE zum Beispielmenü und öffnen Sie die Blink-Skizze.

Das ESP32 DevKit verfügt über eine integrierte LED, die an das GPIO 02 angeschlossen ist. Es ist wichtig zu überprüfen, ob " LED_BUILTIN " von der IDE automatisch erkannt wird. Wenn nicht, müssen Sie die Zeile zum Code hinzufügen:

 int LED_BUILTIN = 2;

Jede ESP32-Karte verfügt über eine interne LED, die an einen anderen GPIO angeschlossen ist

 / * ESP 32 Blink Schaltet eine LED für eine Sekunde ein und dann für eine Sekunde wiederholt aus. Der ESP32 verfügt über eine interne blaue LED an D2 (GPIO 02) * / int LED_BUILTIN = 2; void setup () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, HIGH); // LED einschalten (HIGH ist der Spannungspegel) Verzögerung (1000); // warte auf ein zweites digitalWrite (LED_BUILTIN, LOW); // Schalten Sie die LED aus, indem Sie die Spannung auf LOW verzögern (1000). // warte mal eine Sekunde }

Unterhalb der internen LED blinkt (beachten Sie das blaue Licht) zusammen mit einer an GPIO 2 angeschlossenen externen LED:

Es gibt verschiedene Boards mit unterschiedlichen Pin-Maps auf dem Markt. Das obige Diagramm zeigt die Karte, die ich benutze. Sie finden es hier: / ESP32-Development-Board

Perfekt! DigitalWrite () funktioniert also perfekt, genauso wie ESP8266 und Arduino. Übrigens funktioniert DigitalRead () auch auf die gleiche Weise, um einen digitalen Eingang zu lesen, wie zum Beispiel einen Druckknopf.

Schritt 5: Der Berührungssensor

Lassen Sie uns zu einer neuen coolen Funktion springen, dem Berührungssensor !

Der ESP32 verfügt über 10 interne kapazitive Berührungssensoren. Sie können es beispielsweise als Schaltflächen verwenden.

Diese Sensoren sind mit mehreren GPIOs verbunden:

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

Um sie zu lesen, müssen Sie die folgende Funktion verwenden: touchRead (Touch Pin #);

Um beispielsweise den Berührungssensor 0 (T0) zu lesen, müssen Sie Folgendes tun:

 int value = touchRead (4);

Erstellen wir einen Code, in dem die LED leuchtet, wenn wir den Sensor T0 (GPIO4) berühren.

Verwenden Sie den seriellen Monitor, um die vom Sensor gelesenen Werte zu überprüfen und den Code richtig anzupassen.

Unter dem vollständigen Code:

 / ******************************************************** **** * ESP32 Touch Test und LED Ctrl * Touch Pin ==> Touch0 ist T0 und befindet sich auf GPIO 4 (D4). * LED-Pin ==> D2 * * MJRoBot.org 6Sept17 **************************************** **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; void setup () {Serial.begin (115200); Verzögerung (1000); // gib mir Zeit, den seriellen Monitor aufzurufen Serial.println ("ESP32 Touch Test"); pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, LOW); } void loop () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // Wert mit T0 abrufen if (touch_value <50) {digitalWrite (LED_PIN, HIGH); } else {digitalWrite (LED_PIN, LOW); } delay (1000); }}

Und unter dem ESP32 funktioniert:

Schritt 6: Analogeingang

Lassen Sie uns nun testen, wie analoge Wertsignale eingegeben werden.

Es gibt insgesamt 18 x 12-Bit-ADC-Eingangskanäle gegenüber nur 1 x 10-Bit-ADC auf der NodeMCU.

GPIO ADC-Kanal

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

Um den Analogeingang zu lesen, müssen Sie dasselbe tun wie mit Arduino und ESP8266:

 int analog_value = analogRead (36);

Es ist sehr wichtig zu beachten, dass die ESP32-ADCs eine Auflösung von 12 Bit haben (gegenüber 10 Bit bei ESP8266 und Arduino), sodass der Gesamtbereich der ADC-Werte 4.095 beträgt (stattdessen 1.027 bei Arduinos und ESP8266), wenn maximal 3, 3 V angelegt werden seine Eingänge.

Verwenden Sie für die Eingabe ein 10K-Ohm-Potentiometer, das von 3, 3 V und GND angeschlossen wird. Verwenden wir den variablen Ausgang als Eingang für ESP32-ADC-Pins. Das obige Diagramm zeigt das an GPIO 36 angeschlossene Potentiometer, das der ADC1-Kanal 0 ist. Probieren Sie auch andere Eingänge auf Ihrer Karte aus.

Führen Sie den folgenden einfachen Code aus:

 / ******************************************************** ***** * ESP32-Analogeingangstest * Analogeingang: ADC_1_0-Pin ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 **************************************************** ********* / // Analogeingang #define ANALOG_PIN_0 36 int analog_value = 0; void setup () {Serial.begin (115200); Verzögerung (1000); // gib mir Zeit, den seriellen Monitor aufzurufen Serial.println ("ESP32 Analog IN Test"); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); Verzögerung (500); }}

Drehen Sie Ihr Potentiometer und beobachten Sie auf dem IDE Serial Monitor die Messungen von Null bis 4.095.

Schritt 7: Dimmen einer LED: Analogausgang mit PWM

Wenn wir eine LED auf dem ESP8266 oder einem Arduino "dimmen" möchten, können wir einfach einen Befehl wie analogWrite () verwenden, der den PWM-Wert seines Ausgangs variiert und einen analogen Wert simuliert. Leider haben wir noch keinen solchen Befehl für den ESP32 auf Arduino IDE entwickelt. Die sehr gute Nachricht ist jedoch, dass alle 36 ESP32-GPIOs über eine PWM-Funktion verfügen. Das ist großartig! Nur müssen wir komplexeren Code verwenden, um das gleiche Ergebnis zu erzielen.

Programmieren wir also eines dieser GPIOs mit einem PWM-Ausgangssignal.

Unter diesem Link finden Sie ein sehr gutes Tutorial mit Details zur Funktionsweise von PWM: esp32-arduino-led-pwm-fading.

Das erste, was Sie über ein zu erzeugendes PWM-Signal nachdenken müssen, ist seine Frequenz. Wir werden einen Wert von 5000 Hz verwenden, der mit der LED gut funktioniert. Wir müssen auch den LED-PWM-Kanal und die Auflösung des PWM-Arbeitszyklus in Bit angeben. Wir können einen Kanal von 0 bis 15 und eine Auflösung zwischen 1 und 16 Bit wählen. Wir werden Kanal 0 und eine Auflösung von 8 Bit verwenden.

 int freq = 5000; int ledChannel = 0; int Auflösung = 8;

Verwenden wir GPIO2, an dem unsere externe LED (und die interne) angebracht ist.

 #define LED_PIN 2

Diese Parameter müssen während der setup () -Phase mit den folgenden Funktionen definiert werden:

 void setup () {ledcSetup (ledChannel, freq, Auflösung); ledcAttachPin (LED_PIN, ledChannel); }}

Um die LED mit einer bestimmten Helligkeit einzuschalten, müssen wir den "Arbeitszyklus" definieren.

Um beispielsweise die LED auszuschalten, muss das Tastverhältnis Null sein und die Funktion ledcWrite (ledChannel, Tastverhältnis) verwendet werden, um den Wert über einen bestimmten PWM-Kanal zu senden:

 intutyCycle = 0; ledcWrite (ledChannel, utyCycle);

Unterschiedliche Werte der DutyCycle-Variablen schalten die LED mit unterschiedlicher Helligkeit ein. Diese Variable, DutyCycle, variiert von 0 bis 255, sobald die verwendete Auflösung 8 Bit beträgt.

Wir können das Potentiometer (verbunden mit der Variablen analog_value ) verwenden, um die VariableutyCycle manuell einzurichten. Sobald sich ihr Wertebereich unterscheidet, verwenden wir eine Kartenfunktion, um die Ein- und Ausgabe abzugleichen:

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

Unter dem vollständigen Code:

 ********************************************************** *** * ESP32-Analogeingangs- / Ausgangstest * Analogeingang: ADC_1_0-Pin ==> GPIO36 (VP). * PWM LED Pin ==> GPIO 02 * * MJRoBot.org 6Sept17 *************************************** ****************** / // Analogeingang #define ANALOG_PIN_0 36 int analog_value = 0; // PMW LED #define LED_PIN 2 int freq = 5000; int ledChannel = 0; int Auflösung = 8; intutyCycle = 0; void setup () {Serial.begin (115200); Verzögerung (1000); // gib mir Zeit, den seriellen Monitor aufzurufen Serial.println ("ESP32 Analog IN / OUT Test"); ledcSetup (ledChannel, Freq, Auflösung); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, utyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); utyCycle = map (analog_value, 0, 4095, 0, 255); ledcWrite (ledChannel, utyCycle); Verzögerung (500); }}

Das ist es!

Schritt 8: Servosteuerung

Lassen Sie uns einen Servomotor mit der PWM-Fähigkeit unseres ESP32 steuern. Der Code ist im Grunde derselbe, der zur Steuerung der LED-Helligkeit verwendet wurde.

Zunächst ist zu beachten, dass die Frequenz für die Arbeit mit einem Mikro-Servo 50 Hz beträgt. Daher müssen wir den Frequenzparameter auf 50 ändern (anstelle von 5.000, die mit LED verwendet werden). Wir müssen auch den LED-PWM-Kanal und die Auflösung des PWM-Arbeitszyklus in Bit angeben. Wir werden wieder Kanal 0 und eine Auflösung von 8 Bit verwenden.

 int freq = 50; int channel = 0; int Auflösung = 8;

Der Servo wird an GPIO 5 angeschlossen (siehe Schaltplan oben).

 #define SERVO_PIN 5

Wie bei der LED müssen diese Parameter während der Setup () - Phase mithilfe der folgenden Funktionen definiert werden:

 void setup () {ledcSetup (Kanal, Frequenz, Auflösung); ledcAttachPin (SERVO_PIN, Kanal); }}

Um das Servo in einem bestimmten Winkel zu positionieren, müssen wir den "Arbeitszyklus" definieren (siehe obiges Diagramm).

Um beispielsweise das Servo um 90 Grad zu positionieren, muss das Tastverhältnis ungefähr 21 sein und die Funktion ledcWrite (ledChannel, utyCycle) sollte verwendet werden, um den Wert durch den PWM-Kanal zu senden:

 intutyCycle = 21; ledcWrite (Kanal, DutyCycle);

Unterschiedliche Werte der DutyCycle-Variablen positionieren das Servo mit unterschiedlichen Winkeln. Diese Variable, DutyCycle, sollte zwischen 10 und 32 variieren (dieser Bereich wurde manuell ermittelt).

Wie bei der LED kann das Potentiometer (verbunden mit der Variablen analog_value ) verwendet werden, um die DutyCycle-Variable manuell einzurichten und so die Servoposition zu ändern. Sobald ihre Wertebereiche unterschiedlich sind, verwenden wir eine Kartenfunktion, um Eingabe und Ausgabe abzugleichen:

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

Unter dem vollständigen Code:

 / ******************************************************** **** * ESP32-Servosteuerung * Analogeingang: ADC_1_0 Pin ==> GPIO36 (VP). * PWM SERVO Pin ==> GPIO 05 * * MJRoBot.org 6Sept17 *************************************** ****************** / // Analogeingang #define ANALOG_PIN_0 36 int analog_value = 0; // PMW SERVO #define SERVO_PIN 5 int freq = 50; int channel = 0; int Auflösung = 8; intutyCycle = 21; void setup () {Serial.begin (115200); Verzögerung (1000); // gib mir Zeit, den seriellen Monitor aufzurufen Serial.println ("ESP32 Servo Control"); ledcSetup (Kanal, Frequenz, Auflösung); ledcAttachPin (SERVO_PIN, Kanal); ledcWrite (Kanal, DutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Duty Cycle ==>"); Serial.println (utyCycle); utyCycle = map (analog_value, 0, 4095, 10, 33); ledcWrite (Kanal, DutyCycle); Verzögerung (50); }}

Jetzt können wir mit dem Ultraschallsensor über dem Servo arbeiten und ein IoT-Radar bauen!. Aber dies wird ein weiteres Tutorial sein! ;-);

Schritt 9: Verbindung zum Internet herstellen: Lokaler Zeitstempel

Nachdem wir einige der digitalen / analogen und analogen GPIO- und Ein- / Ausgabefunktionen getestet haben, verbinden wir unseren ESP32 im Internet!

Mit der ESP8266-Familie haben wir dafür die Bibliothek esp8266wifi.h verwendet . Mit dem ESP32 wird folgende Bibliothek verwendet:

Ein sehr einfaches Beispiel wäre die Programmierung unseres Boards, um die Ortszeit aus dem Internet zu erfassen. Dies ist eine sehr gute Funktion für Projekte. Der folgende Code erledigt dies für uns:

 / ******************************************************** ************* * Lokaler Zeitstempel mit ESP32 * Entwickelt von Marcelo Rovai - 8. September 2017 ********************** ******************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // In Sekunden #define NTP_INTERVAL 60 * 1000 // In Millisekunden #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 (); }}

Sie können am seriellen Monitor die Ortszeit sehen, die gestempelt wird.

Schritt 10: Einfacher WiFi-Server

Testen wir nun unseren ESP32 als einfachen WiFi-Server.

Öffnen Sie das Menü BEISPIELE auf Ihrer Arduino IDE und rufen Sie die Skizze ESP32 WiFi / SimpleWiFiServer.ino auf:

Über dieses Programm:

WiFi Web Server LED blinkt

Erstellt für arduino 25 Nov 2012 von Tom Igoe
Portiert für sparkfun esp32 31.01.2017 von Jan Hendrik Berlin

Ein einfacher Webserver, mit dem Sie eine LED über das Web blinken lassen können. In dieser Skizze wird die IP-Adresse Ihres ESP32-WLAN-Netzwerks auf dem seriellen Monitor gedruckt. Von dort aus können Sie diese Adresse in einem Webbrowser öffnen, um die LED an Pin 5 ein- und auszuschalten.

Wenn die IP-Adresse Ihres Boards beispielsweise 10.0.1.40 lautet :

//10.0.1.40/H schaltet die LED ein

//10.0.1.40/L
schaltet die LED aus

Dieses Beispiel wurde für ein Netzwerk mit WPA-Verschlüsselung geschrieben. Ändern Sie für WEP oder WPA den Aufruf von Wifi.begin () entsprechend.

Schaltung: LED an Pin 5 angeschlossen

Verwenden wir das Programm also ohne wesentliche Änderungen. Ändern Sie den externen LED-Pin in GPIO5

Natürlich, wenn Sie den Code für GPIO2 ohne Änderung der Hardware ändern möchten.

Geben Sie zunächst Ihre Netzwerkanmeldeinformationen ein:

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

Und laden Sie es auf Ihr ESP32 hoch.

Das erste, was Sie auf Ihrem seriellen Monitor sehen, sind die Informationen, dass Ihr ESP32 angeschlossen ist, und die IP-Adresse:

 WiFi verbunden. IP-Adresse: 10.0.1.40

Öffnen Sie Ihren bevorzugten Browser und geben Sie diese IP-Adresse ein. Sie erhalten eine Webseite wie oben. Dort können Sie die LED aus der Ferne ein- oder ausschalten.

Schritt 11: DHT 22 - Temperatur und Luftfeuchtigkeit ablesen

Ein sehr nützlicher Sensor für IoT-Projekte ist der DHT 11 oder 22. Sie sind sehr billig und lassen sich leicht in Ihre Projekte integrieren.

Zunächst muss die Adafrut-Bibliothek auf Ihrer IDE installiert sein. Gehen Sie zu ihrem GitHub und laden Sie die aktualisierte Version dieser Bibliothek herunter: DHT-sensor-library

Entpacken Sie die Datei, benennen Sie sie in DHT um und verschieben Sie den vollständigen Ordner in Ihr Arduino Library-Verzeichnis

Als ich zum ersten Mal benutzte, bekam ich eine Nachricht:

Schwerwiegender Fehler: Adafruit_Sensor.h: Keine solche Datei oder kein solches Verzeichnis

Nach einigem Graben stellte ich fest, dass auch die Adafruit Unified Sensor Library installiert sein muss. Also habe ich es mit Arduino IDE Library Manager gemacht (siehe Bild oben). Danach hat alles gut funktioniert, genau wie bei Arduino und NodeMCU.

Lassen Sie uns einige Tests mit diesem Sensor durchführen. Befolgen Sie das obige Schaltbild und installieren Sie den DHT22 wie gezeigt (wenn Sie den Sensor mit dem "Gitter" nach oben betrachten, zählen Sie die 4 Beine von links nach rechts):

Pin VCC ==> 3, 3V
Pin-Daten ==> GPIO 23
N / C.
PIN GND ==> GND

Schließen Sie außerdem einen 10K-Ohm-Widerstand zwischen VCC und Data an.

Das ist es!

Sie können die Beispielskizze "DHT tester.ino" verwenden, die in der Bibliothek enthalten ist, oder Ihre eigene erstellen.

Ich habe einen einfachen Code zum Testen des Sensors geschrieben, wie unten gezeigt:

 / ******************************************************** **** * ESP32 DHT Reading * DHT Input: ==> GPIO23. * * MJRoBot.org 9Sept17 **************************************************** ********* / / * DHT * / #include "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float localHum = 0; float localTemp = 0; void setup () {Serial.begin (115200); Verzögerung (1000); // gib mir Zeit, den seriellen Monitor aufzurufen Serial.println (""); Serial.println ("ESP32 DHT Temperatur und Luftfeuchtigkeit"); Serial.println (""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); Verzögerung (2000); } / ******************************************************** *** * Get Temp / Hum-Daten in Innenräumen ******************************************** ************ / void getDHT () {float tempIni = localTemp; float humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Überprüfen Sie, ob Lesevorgänge fehlgeschlagen sind, und beenden Sie das Programm vorzeitig (um es erneut zu versuchen). {localTemp = tempIni; localHum = humIni; Rückkehr; }}

Sie können das Ergebnis auf dem obigen PrintScreen von Serial Monitor sehen.

Schritt 12: Senden und Empfangen von Daten von einer lokalen Webseite

Überprüfen Sie, was wir bisher in diesem Tutorial behandelt haben:

Digitalausgang: Blinkt eine LED
Digitaleingang: Lesen eines Berührungssensors
Analogeingang: Lesen einer variablen Spannung von einem Potentiometer
Analogausgang: Steuerung der LED-Helligkeit
Analogausgang: Steuerung einer Servoposition
Lesen von Temperatur- / Feuchtigkeitsdaten mit einem digitalen Sensor
Verbindung zum Internet herstellen und Ortszeit abrufen
Erstellen einer einfachen Webseite zum Ein- und Ausschalten einer LED (Empfangen von Daten)

Wir erkennen, dass wir immer noch versuchen müssen, Daten an eine Webseite zu senden. Also machen wir's!

Wir nehmen die von unserem DHT-Sensor erzeugten Daten und den vom Potentiometer bereitgestellten Analogwert und senden sie an die Webseite, die zur Steuerung der LEDs erstellt wurde.

Ich habe mit dem in Schritt 10 verwendeten SimpleWiFiServer-Code begonnen und die entsprechenden Codezeilen hinzugefügt, um die Potentiometer- und DHT-Daten zu erhalten.

Beachten Sie, dass ich die LED wieder auf GPIO 2 gestellt habe, wie Sie auf dem Schaltplan sehen können.

Laden Sie den vollständigen Code von meinem GitHub herunter: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Beachten Sie, dass ich den Code besser organisiert habe und die Schleife () jetzt nur noch ist:

 void loop () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); }}

Neu ist hier die Funktion "WiFiLocalWebPageCtrl ()". Dies ist jedoch genau die ursprüngliche setup () - Funktion, die auf SimpleWebServer verwendet wird. Was ich in diese Funktion aufgenommen habe, sollte auf der Webseite erscheinen (siehe den obigen Druckbildschirm für die Webseite).

 // Der Inhalt der HTTP-Antwort folgt dem Header: // WiFiLocalWebPageCtrl (); client.print ("Temperatur ist jetzt:"); client.print (localTemp); client.print ("oC 
"); client.print (" Luftfeuchtigkeit ist jetzt: "); client.print (localHum); client.print ("% 
"); client.print (" 
"); client.print (" Analog Data: "); client.print (analog_value); client.print (" 
"); client.print (" 
"); client.print (" Klicken Sie hier, um die LED einzuschalten. 
"); client.print (" Klicken Sie hier, um die LED auszuschalten. 
");

Beachten Sie, dass die Werte für Temperatur, Luftfeuchtigkeit und Analog jedes Mal aktualisiert werden, wenn Sie auf die Links klicken, die zur LED-Steuerung verwendet werden, oder wenn Sie die Seite aktualisieren.

Schritt 13: Fazit

Wir könnten hier weiter und weiter machen, aber wir würden niemals alle ESP32-Funktionen oder -Potentiale abdecken. Mit diesem großartigen IoT-Gerät gibt es noch viel zu entdecken. In meinem nächsten Tutorial erfahren Sie, wie Sie Ihrem ESP32 ein OLED-Display hinzufügen:

ESP32- und OLED-Display: Internet Clock - DHT22

Wir werden bald mit neuen ESP32-Tutorials zurückkehren!

Wie immer hoffe ich, dass dieses Projekt anderen helfen kann, sich in der aufregenden Welt der Elektronik, Robotik und des Internet der Dinge zurechtzufinden!

Bitte besuchen Sie meinen GitHub für aktualisierte Dateien: Spielen mit ESP32 und Arduino IDE

Weitere Projekte finden Sie in meinem Blog: MJRoBot.org

Saludos aus dem Süden der Welt!

Wir sehen uns bei meinem nächsten Unterricht!

Vielen Dank,

Marcelo