Quelltext der Seite ESP32 Sensordaten auslesen

[[Kategorie:Elektronik]]
<div class="row">
  <div class="large-10 columns">
Mit einem ESP32-Mikrocontroller können verschiedenste Sensoren ausgelesen werden. 
In diesem Tutorial wird gezeigt, wie der integrierte Hallsensor und ein Temperatursensor (KY-001) ausgelesen werden kann. Zudem wird erklärt, wie die ausgelesenen Daten über eine Cloud-Applikation visuell dargestellt und online verfügbar gemacht werden können.

__INHALTSVERZEICHNIS__

== Benötiges Material ==
Folgende Materialien werden benötigt:

* ESP32 Mikrocontroller (z.B: von Joy-IT)
* Temperatursensor KY-001 von Joy-IT
* zwei kleine Steckbretter
* kleine Verbindungskabel
* Micro-USB zu USB Kabel (für Verbindung mit Laptop)
* Laptop zum Programmieren 
* Arduino IDE (<b>[https://www.arduino.cc/en/software Link zur Arduino Software]</b>)

Für den eigenen Bedarf können weitere Sensoren angeschlossen werden, die über wenige Codezeilen in das Projekt implementiert werden können.

== Software == 
Der ESP32-Mikrocontroller muss vor Benutzung in die Arduino IDE integriert werden. Dazu kann folgende Anleitung <b>[https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#installing-using-arduino-ide Arduino IDE für ESP32 vorbereiten]</b> befolgt werden.

Zum Schluss wird der ESP32 in die Arduino IDE wie folgt eingebunden:
* Auswahl des ESP32 Dev Module unter "Werkzeuge\Board\ESP32 Arduino":
</div>

    [[Datei:Screenshot01.png|750px|thumb|left|Einbinden des ESP32 in Arduino IDE]]

</div>
<div class="row">

<div class="large-10 columns>
Für den nachstehenden Code werden folgende Bibliotheken benötigt:
* Wifi.h
* OneWire.h
* DallasTemperature.h
Diese können in der Arduino IDE über "Werkzeuge\Bibliotheken verwalten" heruntergeladen werden.


== Sensoren auslesen ==
; Schritt 1: Verbindung zwischen ESP32 und Laptop herstellen: Unter "Werkzeuge\Port" muss der richtige Port (z.B: "Port COM3") ausgewählt werden.

;Schritt 2: Bibliotheken einbinden: <code> #include <OneWire.h></code> und <code> #include <DallasTemperature.h> </code>.

;Schritt 3: belegte Pins der Sensoren deklarieren: <code> byte KY001_Temp_pin = 5; </code> und <code> byte HallSensor_pin = 0; </code>

;Schritt 4: Bibliotheken für den Temperatursensor konfigurieren: <code> OneWire oneWire(KY001_Temp_pin); </code> und <code> DallasTemperature sensors(&oneWire); </code>.

;Schritt 5: Variablen für Temperatur & Hallsensor deklarieren: <code> float Temperature; </code> und <code> float HallSensor; </code>

;Schritt 6: ESP32-Setup festlegen:
<syntaxhighlight lang=c++>
void setup()
{
  Serial.begin(115200);

  pinMode(KY001_Temp_pin, INPUT);

  /* Sensor wird initialisiert */
  sensors.begin();

  /* Sensormessung starten */
  sensors.requestTemperatures();
}
</syntaxhighlight>

;Schritt 7: Loop-Schleife (eigentlicher Programm-Code, der dauerhaft vom ESP32 ausgeführt wird):
<syntaxhighlight lang=c++>
void loop()
{
  /* Sensormessung starten und in der Variable abspeichern */
  sensors.requestTemperatures();
  Temperature = sensors.getTempCByIndex(0);
  HallSensor = hallRead(); 
  
  Serial.print("Temperatur: ");
  Serial.print(Temperature);
  Serial.println(" °C");
  Serial.print("Hallsensor: ");
  Serial.println(HallSensor);

  delay(1000);
}
</syntaxhighlight>

Die ausgelesenen Sensorwerte werden im Seriellen Monitor angezeigt.

== Cloud-Visualisierung ==
Um, auf die Sensorwerte von überall zugreifen zu können, werden die Sensorwerte in die ThingSpeak Cloud-Applikation hochgeladen. Dazu wird ein Konto bei ThingSpeak ersetllt, der ESP32 mit dem lokalen WiFi-Netzwerk verbunden und die Sensorwerte hochgeladen.

;Schritt 1: <b>[https://thingspeak.com/users/sign_up Registrierung bei ThingSpeak]</b> und Verifizierung der Anmelde-Mail

;Schritt 2: Neuen Kanal erstellen im Tab "New Channel" und Kanalnamen bzw. Beschreibung nach Belieben anpassen. In den Kanälen "Temperature" und "Humidty" werden die, zu auswertenden, Sensoren eingetragen. Dabei müssen die Kanäle über den Haken aktiviert werden.
</div>
</div>
<div class="row">
<div class="large-5 columns>
[[Datei:BP Elektronik ThingSpeak Kanal erstellen.png|500px|thumb|left|Kanal bei ThingSpeak.com erstellen]]
</div>
</div>
<div class="row">
<div class="large-10 columns>

;Schritt 3: Registerkarte "API Keys" öffnen und die "Write API" und "Channel ID" notieren. 

;Schritt 4: Programmcode anpassen:
* WiFi Bibliothek importieren: <code> #include <WiFi.h> </code>
* Lokale Netzwerk-Daten (SSID bzw. WLAN-Name) initialisieren: <code> const char* ssid = "WLAN Name eingeben"; </code> und <code> const char* password = "WLAN Passwort eingeben"; </code>
* ThingSpeak Konto und Kanäle verknüpfen: <code> unsigned long myChannelNumber = Eigene Kanal-ID eingeben; </code>; <code> String APIKEY = "Write API KEy eingeben" </code> und <code> const char* host = "api.thingspeak.com"; </code>
* WiFi-Client starten: <code> WiFiClient client; </code>
* ESP32 mit lokalem Netzwerk verbinden: <code> void Connect_WiFi() {WiFi.begin(ssid, password);while(WiFi.status() != WL_CONNECTED){delay(1000);}} </code>
* Sensor-Funktion zum Auslesen der Sensoren deklarieren: <code> void Sensors( {sensors.requestTemperatures();Temperature = sensors.getTempCByIndex(0);HallSensor = hallRead();} </code>
* Sensoren initialisieren & Wifi-Verbindung starten: <code> void setup( {Serial.begin(115200);pinMode(KY001_Temp_pin, INPUT);sensors.begin();Connect_WiFi();client.connect(host, 80);} </code>
* Loop-Programm zum Auslesen der Sensorwerte und zum Senden der Werte zur ThingSpeak-Cloud alle 15 Sekunden: <code> void loop(){client.connect(host,80);Sensors();client.print("GET /update?api_key=API-Key eingeben=");client.print(String(Temperature));client.print("&field2=");client.print(String(HallSensor));client.print(" HTTP/1.0\r\nHost: api.thingspeak.com\r\n\r\n");delay(15000);} </code>

;Schritt 5: Cloud-Visualisierung anpassen:
</div>
</div>
<div class="row">
<div class="large-5 columns>
[[Datei:BP Elektronik ThingSpeak Chart.png|500px|thumb|zentriert|ThingSpeak Chart]]
</div>
<div class="large-5 columns>
[[Datei:BP Elektronik ThingSpeak Chart-Options.png|415px|thumb|zentriert|ThingSpeak Chart-Options]]
</div>
</div>
<div class="row">
<div class="large-10 columns>


== Fazit/Diskussion der Cloud-Visualisierung ==
=== Cloud-Visualisierung über ThingSpeak ===
Generell ist die Visualisierung der Sensordaten über die ThingSpeak Cloud intuitiv und, mit wenigen Codezeilen einzubinden. 

Dabei können verschiedene Darstellungsarten der Sensordaten gewählt werden. Folgende <b> [https://de.mathworks.com/help/thingspeak/createchart.html Optionen] </b> stehen zur Verfügung :
* Titel- und Achsenbeschriftung
* Farbe des Graphen/der Messwerte
* Hintergrundfarbe
* Darstellungsart: 
** Linien
** Balken
** Spalten
** spline
** Stufen
* Begrenzung des Wertebereichs  z.B. über:
** Zeitskala/Zeitabständen
** Mittelwert/Summe
** x- und y-Wertebereich

Desweiteren können alle gemessenen Sensordaten als .JSON-, .XML- oder .CSV-Datei exportiert werden .

Zur Nutzung der ThingSpeak-Visualisierung wird ein WLAN-Netzwerk in Reichweite benötigt.

=== Visualisierung per eigenem WebServer ===
Die Visualisierung der Sensordaten über einen eigenen WebServer, mit dem ESP32 als AccessPoint, benötigt kein eigenes WLAN-Netzwerk in Reichweite. Mit einem zusätzlichen Akku kann der ESP32 somit überall zur Sensoraufzeichnung genutzt werden.

Das Einrichten eines WebServer ist in kurzer Zeit möglich. Allerdings gestaltet sich die visualisierte Darstellung der Sensordaten mithilfe eines Diagramms und die Möglichkeit zum Export der Daten sehr komplex. Bei Interesse, gerne im folgenden Artikel nachschauen: <b> [https://didaktik.pi5.physik.uni-stuttgart.de/w/index.php/BP:ESP32-Webserver_f%C3%BCr_Sensordaten ESP32-Webserver für Sensordaten] </b>.

== Programmcode ==
Im Nachfolgenden wird der komplette Programmcode zum Auslesen des Temperatursensors und zum Hochladen von Temperatur- und Hallsensor-Daten in die ThingSpeak-Cloud aufgeführt:
=== Sensoren auslesen ===
<syntaxhighlight lang=c++>
#include <OneWire.h>
#include <DallasTemperature.h>

/* Pin der Sensoren deklarieren*/
byte KY001_Temp_pin = 5;
byte HallSensor_pin = 0;

/*Bibliotheken für Temp-Sensor konfigurieren*/
OneWire oneWire(KY001_Temp_pin);
DallasTemperature sensors(&oneWire);

/*Temperatur & HallSensor als float Variable deklarieren*/
float Temperature;
float HallSensor;

void setup()
{
  Serial.begin(115200);

  pinMode(KY001_Temp_pin, INPUT);

  /* Sensor wird initialisiert */
  sensors.begin();

  /* Sensormessung starten */
  sensors.requestTemperatures();
}

void loop()
{
  /* Sensormessung starten und in der Variable abspeichern */
  sensors.requestTemperatures();
  Temperature = sensors.getTempCByIndex(0);
  HallSensor = hallRead(); 
  
  Serial.print("Temperatur: ");
  Serial.print(Temperature);
  Serial.println(" °C");
  Serial.print("Hallsensor: ");
  Serial.println(HallSensor);

  delay(1000);
}
</syntaxhighlight>

=== Cloud-Visualisierung ===
<syntaxhighlight lang=c++>
#include <WiFi.h>
#include <OneWire.h>
#include <DallasTemperature.h>

/* Local WiFi ssid and password */
const char* ssid = "WiFi Name eingeben";
const char* password = "WiFI Passwort eingeben";

/* Thingspeak API key, channel number and host name */
unsigned long myChannelNumber = 1796802;   // Hier eigene Kanal-ID von ThingSpeak anstatt 1796802 eingeben
String APIKEY = "XPUQVW0RUWBX3P0D";        // Hier eigenen Write API-Key anstatt XPUQVW0RUWBX3P0D eingeben
const char* host = "api.thingspeak.com";

/* Sensoren deklarieren*/
byte KY001_Temp_pin = 5;
byte HallSensor_pin = 0;

/* Bibliotheken für Temp-Sensor konfigurieren */
OneWire oneWire(KY001_Temp_pin);
DallasTemperature sensors(&oneWire);

/* Temperatur & HallSensor als float Variable deklarieren */
float Temperature;
float HallSensor;

/* WiFiClient starten */
WiFiClient client;

/* This function connects the ESP32 to the local WiFi network. */
void Connect_WiFi()
{
  WiFi.begin(ssid, password);
  while(WiFi.status() != WL_CONNECTED)
  {
    delay(1000);
  }
}

/* This function reads the ambient temperature and stores in variable "Temeperature" */
void Sensors()
{
  sensors.requestTemperatures();
  Temperature = sensors.getTempCByIndex(0);
  HallSensor = hallRead();
}

/* Initialize sensors, connect to local WiFi, connect to HTTP */
void setup()
{
  Serial.begin(115200);

  pinMode(KY001_Temp_pin, INPUT);

  sensors.begin();

  Connect_WiFi();
  client.connect(host, 80);
}

/* Main Program which reads the temperature and send the data to Thingspeak every 15 seconds */
void loop()
{
  client.connect(host,80);
  Sensors();
  client.print("GET /update?api_key=XPUQVW0RUWBX3P0D&field1=");   // Hier eigenen Write API-Key anstatt XPUQVW0RUWBX3P0D eingeben
  client.print(String(Temperature));
  client.print("&field2=");
  client.print(String(HallSensor));
  client.print(" HTTP/1.0\r\nHost: api.thingspeak.com\r\n\r\n");
  delay(15000);
}
</syntaxhighlight>

== Literatur ==
* Ibrahim, D. & Ibrahim, A. (Hrsg.) (2018). Das offizielle ESP32-Handbuch. Aachen: Elektor Verlag. ISBN 978-3-89576-329-8
</div>
</div>

{|
https://i.creativecommons.org/l/by-nc-sa/3.0/de/88x31.png
Universität Stuttgart, 5. Physikalisches Institut, AG Physik und ihre Didaktik, lizenziert unter [https://creativecommons.org/licenses/by-nc-sa/4.0/deed.de CC BY-NC-SA 4.0]
|}