Praktische Smart Home und Internet der Dinge Anwendungen mit Arduino und ESP Microcontrollern E-Book

Daniel Perl

• Herausgeber: epubli
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Deutsch
• Veröffentlichungsjahr: 2024

Seitenzahl: 189

Beschreibung

Viele Bücher über Microcontroller behandeln sehr viel Theorie über deren Anschlüsse, technische Daten und Möglichkeiten. Wenn es ihnen geht wie mir und sie keine Lust auf graue Theorie und Erklärungen von Funktionen haben, deren Sinn sie anfangs sowieso nicht verstehen, dann ist dieses Buch genau das Richtige für sie, denn darauf verzichtet dieses Buch komplett. Bei diesem Buch handelt es sich um ein Buch von einem Bastler für Bastler. Sie werden in diesem Buch über die Programmierung und Konstruktion von Anwendungen mit den Microcontrollern der Arduino- und ESP-Reihe ab dem ersten Kapitel direkt in die Praxis einsteigen. Dies bedeutet für sie, dass sie in jedem Kapitel eine Anwendung konstruieren und programmieren in der Programmiersprache C++. Die Funktionen eines Microcontrollers sowie die Theorie zu jedem Projekt werden ihnen während der Konstruktion vermittelt. Außerdem werden die Grundkonzepte der Programmiersprache C++ und der Programmcode Stück für Stück erläutert. Insgesamt beinhaltet das Buch 12 Anwendungen von einer einfachen Temperaturmesstation und einer Musikbox bis hin zu einem kleinen Smart Home, einem Teebeutelheber, einer Bewässerungsstation, einer WLAN-gesteuerten Musikbox und einer WLAN-fähigen Messstation für den von einer Solaranlage erzeugten Strom, dessen Daten auch mit dem Handy per Telegram-Messenger abgerufen werden können. Der Höhepunkt zum Schluss wird die Kontruktion und Programmierung einer automatisierten Kühlschrankspeichersteuerung zur Erfassung und Organisation von Lebensmitteln mit Hilfe der RFID-Technologie erklärt, die ich während meiner Weiterbildung zum Mechatroniktechniker entwickelt habe.

Leseprobe

Praktische Smart Home und Internet der Dinge Anwendungen mit Arduino und ESP Microcontrollern

Daniel Perl

Text und Gestaltung: Copyright by Daniel Perl

Verlag:

Daniel Perl

c/o Gustav Perl

Wannisweg 4

94209 Regen

Druck: epubli - ein Service der neopubli GmbH, Berlin

Inhaltsverzeichnis

Vorwort 5

Arduino IDE und Voreinstellungen 6

Anwendung 1: Die LED-Steuerung 12

Anwendung 2: Die Wetterstation mit LCD-Display 16

Anwendung 3: Die Temperaturmessstation mit 2 Arduinos 26

Anwendung 4: Die Arduino Bewässerungsstation 34

Anwendung 5: Der Teebeutelheber 40

Anwendung 6: Die Musikbox 52

Anwendung 7: Das kleine Smart Home 71

Anwendung 8: Die Temperaturmessstation mit SD-Kartenleser 83

Anwendung 9: Die WLAN-Temperaturmessstation 98

Anwendung 10: Die ESP8266 WLAN-Musikanlage 112

Anwendung 11: Die WLAN-Solarstrommessstation 128

 Vorwort zum Technikerprojekt 150

Anwendung 12: Die automatisierte Kühlschrankspeichersteuerung 152

Das Beschreiben der RFID-Karten 163

Der komplette Programmcode 165

Ordnen der Waren am Display 306

Die Löschfunktion 310

      Abrufen des Kühlschrankinhalts mit dem Telegram-Messenger 315

Zurücksetzen auf Werkszustand 323

Benachrichtigung bei baldigem Erreichen des Mindesthaltbarkeitsdatums 325

Einlesen der Ware mit dem RFID-Kartenleser 328

Vorwort

Viele Bücher über Microcontroller behandeln sehr viel Theorie über deren Anschlüsse, technische Daten und Möglichkeiten. Wenn sie jedoch keine Lust auf graue Theorie und Erklärungen von Funktionen haben, deren Sinn sie anfangs sowieso nicht verstehen, dann ist dieses Buch genau das Richtige für sie, denn darauf verzichtet dieses Buch komplett. Bei diesem Buch handelt es sich um ein Buch von einem Bastler für Bastler.

Sie werden in diesem Buch über die Programmierung und Konstruktion von Anwendungen mit den Microcontrollern der Arduino- und ESP-Reihe ab dem ersten Kapitel direkt in die Praxis einsteigen. Dies bedeutet für sie, dass sie in jedem Kapitel eine Anwendung konstruieren und programmieren in der Programmiersprache C++. Die Funktionen eines Microcontrollers sowie die Theorie zu jedem Projekt werden ihnen während der Konstruktion vermittelt. Außerdem werden die Grundkonzepte der Programmiersprache C++ und der Programmcode Stück für Stück erläutert.

Angefangen wird natürlich mit kleinen, einfachen Projekten in denen die Grundlagen erläutert werden. Danach steigt der Umfang und Schwierigkeitsgrad der Projekte und es werden Schritt für Schritt verschiedene Typen von Microcontrollerboards wie der Arduino Uno oder der ESP8266 oder der EP32 vorgestellt, mit denen sie ihre eigenen Smart Home Anwendungen konstruieren können.

Auch das Internet der Dinge, die Steuerung von Microcontrollern über das Internet, zum Beispiel mit Hilfe einer lokalen Website oder durch den Telegram-Messenger, und die Vernetzung von Microcontrollern untereinander spielt in den fortgeschrittenen Projekten eine große Rolle.

Zum Schluss wird die Kontruktion und Programmierung einer automatisierten Kühlschrankspeichersteuerung zur Erfassung und Organisation von Lebensmitteln mit Hilfe der RFID-Technologie erklärt, die ich während meiner Weiterbildung zum Mechatroniktechniker entwickelt habe.

Arduino IDE und Voreinstellungen

Bevor wir die Microcontroller programmieren können, brauchen wir dafür eine Entwicklungsumgebung, in der wir den Programmcode schreiben und dann auf den Microcontroller speichern. Wir verwenden für unser Buch hier die Arduino IDE. Man kann sie ganz einfach installieren. Als erstes einfach bei google Arduino cc eingeben und schon erscheint die offizielle Arduino Homepage. Diese Seite einfach aufrufen.

Auf den Reiter Software klicken und im folgenden Menü die passende Downloadoption wählen.

Im darauffolgenden Menu einfach den Punkt "Just download" auswählen. Nach dem Download erscheint auf dem Desktop das Symbol der Arduino IDE.

Öffnet die IDE, schließt einen Arduino Microcontroller an und überprüft, ob ihr einen Port auwählen könnt unter dem Reiter Werkzeuge.

Sollte die Portauswahl nicht möglich sein, was bei chinesischen Kopien der Arduino Boards oft der Fall ist, muss man zusätzliche Treiber installieren für deren Chips, gennant CH340/341.

Gebt bei Google einfach ch340 Treiber ein und wählt gleich die erste website von makershop. Dort kann man dann die richtigen Treiber einfach auswählen.

Danach wird man auf eine chinesische Seite weitergeleitet. Zum Glück muss man kein Chinesisch sprechen um zu wissen, was man tun muss, denn man muss einfach nur auf den blauen Balken klicken.

Es wird eine ZIP-Datei heruntergeladen. Nach dem Download muss diese im Verzeichnis, in das sie heruntergeladen wurde, noch entpackt werden.

Man markiert alle Dateien in der ZIP-Datei und klickt dann auf den Button entpacken. Dann sucht man im Download-Verzeichnis die Datei Setup und installiert damit die Treiber.

Nachdem die Treiber installiert wurden, sollte die Arduino IDE nun alle China-Kopien der verwendeten Arduinos erkennen.

Anwendung 1: Die LED-Steuerung

Unser erstes Projekt ist eine ganz einfache Steuerung für eine LED. Obwohl dieses Projekt sehr simpel erscheint, beinhaltet es viele grundlegende Programmierbefehle, die man in so gut wie jedem Projekt benötigt. Ziel dieses Projektes ist es, dass die grüne LED ein- und ausgeschaltet wird mit einer Dauer von jeweils einer Sekunde. Verwendet wird für dieses Projekt ein Arduino Mega2560 und eine grüne LED.

Die grüne LED wird wie im Bild dargestellt angeschlossen. Die kürzere Seite wird an Ground angeschlossen und die längere an den Pin 8 des Arduino. In der Arduino IDE wird im Reiter Werkzeuge das Board Arduino Mega2560 ausgewählt und dann der Port, an dem es angeschlossen ist.

Der komplette Programmcode für dieses Projekt wird im Folgenden genau erläutert und hier bereits abgedruckt.

#define LED 8

unsigned long Startzeit;

unsigned long Zeitaktuell;

void setup() {

Serial.begin(9600);

pinMode(LED, OUTPUT);

}

void loop() {

if (Zeitaktuell - Startzeit >= 1000){

  digitalWrite(LED, !digitalRead(LED));

}

Serial.println("Programm läuft durchgehend");

}

Der erste Befehl #define LED 8 legt fest, dass die grüne LED unter dem Namen LED am Pin 8 angeschlossen ist. Es handelt sich hier um einen digitalen Pin. Möchte man die LED an einem analogen Pin anschließen, ist dies möglich, dann müsste man aber A8 schreiben, damit der Arduino weiß, dass die LED am analogen und nicht am digitalen Pin 8 angeschlossen ist. Danach legt ihr fest, dass es ich bei den Variablen Startzeit und Zeitaktuell um unsigned long Werte handelt. Es gibt in C++ verschiedene Typen für Variablen wie etwa Integer, Float, String usw. Es werden alle gängigen Typen in den folgenden Projekten erklärt. Ein unsigned long ist eine Variable vom Typ long ohne Vorzeichen und hat eine größe von 4 Byte. Er kann Werte zwischen 0 und 4.294.967.295 annehmen. Diese Definition muss immer ganz an Anfang erfolgen, damit für diese Variablen der benötigte Speicherplatz reserviert wird.

Als nächstes kommen wir zum setup. Jeder Microcontroller hat einen Programmteil den er einmal beim Start ausführt und einen Programmteil, den er immer wieder ausführt. Der Programmteil, der nur einmalig ausgeführt wird, befindet sich in der Funktion void setup(). Danach folgen geschweifte Klammern, zwischen denen der gesamte Programmteil für das setup steht.

Der erste Befehl im Setup lautet Serial.begin(9600). Mit diesem Befehl startet man die serielle Schnittstelle des Microcontrollers, über die man Befehle an ihn senden kann oder sich die Werte von Variablen ausgeben lassen kann.

Jeder Anschluss kann bei einem Arduino als Eingang oder Ausgang dienen. Dieser Zustand muss aber vorher festgelegt werden. Dies geschieht mit dem Befehl pinMode(LED, OUTPUT). Hier muss wie überall in C++ die Groß- und Kleinschreibung genau beachtet werden. In diesem Fall handelt es sich beim Anschluss 8, genannt LED, um einen Ausgang. Einen Eingang würde man mit INPUT festlegen.

Nun wird der Variable Startzeit der Wert der Funktion millis() zugewiesen. millis() ist eine Funktion, die die Zeit in Millisekunden misst, die seit dem Start des Programms vergangen ist. Man verwendet sie, wenn eine gewisse Zeit gemessen werden muss, um diesen Wert dann zu verwenden.

Damit sind alle Befehle, die nur einmal erfolgen sollen, programmiert. Jetzt geht es weiter mit der zweiten Hauptfunktion eines Microcontrollers, nämlich der Schleife. Diese wird immer wieder ausgeführt, bis der Microcontroller abgeschaltet wird. Ausgeführt wird die Schleife in der Funktion void loop() und beinhaltet in der Regel das Hauptprogramm des Microcontrollers.  Als erstes weist man der Variable Zeitaktuell den Wert der Funktion millis() zu. Dies macht man, damit die Variable Zeitaktuell immer weiterzählt, denn das Ziel ist es ja, dass die LED eine Sekunde eingeschaltet ist und dann wieder eine Sekunde ausgeschaltet. Deswegen muss die aktuelle Zeit immer wieder aktualisiert werden.

Danach folgt eine if-Bedingung. Dieser Befehl wird benötigt, wenn ein gewisses Ereignis nur eintreten soll, wenn eine gewisse Bedingung erfüllt ist. Die Syntax lautet: if ( Bedingung ) { Anweisungen }.

In der  Bedingung if (Zeitaktuell - Startzeit >= 1000) wird festgelegt, dass die Bedingung erfüllt ist, wenn die Variable Zeitaktuell abzüglich der Variable Startzeit größer oder gleich 1000 Milllisekunden ist.

Ist dies der Fall, dann wird mit dem Befehl digitalWrite(LED, !digitalRead(LED)) die LED entweder ausgeschaltet oder eingeschaltet. Dies erfolgt wie folgt. Es wird der Zustand der LED mit dem Befehl digitalRead() ausgelesen und dann wird das Gegenteil davon auf Pin 8 gespeichert mit einem ! vor dem Befehl digitalRead(). Das Gegenteil eines Zustandes erzeugt man in C++ mit dem Zeichen ! vor dem Befehl oder eines Operators. Dies ist sehr praktisch, wenn der Zustand unbekannt ist, aber man davon das Gegenteil benötigt. Es gäbe auch noch die Möglichkeiten, die LED mit dem Zustand HIGH oder LOW zu steuern. Der Befehl dazu lautet: digitalWrite(LED, HIGH) und digitalWrite(LED, LOW).

Nachdem der Zustand der LED geändert wurde, wird die Variable Startzeit aktualisiert, indem man ihr den Wert der Funktion Zeitaktuell zuweist. Somit wird die Variable Startzeit immer um 1000 Millisekunden erhöht. Die millis()-Funktion ist extrem nützlich, wenn der Microcontroller eine gewisse Zeit messen oder abzählen muss, aber das Programm nicht stoppen soll, was bei Verwendung des Befehls delay() der Fall wäre. Darauf wird in den nächsten Projekten eingegangen.

Zum Schluss soll der Arduino eine Meldung über den seriellen Monitor ausgeben. Dies erfolgt mit dem Befehl Serial.print() oder Serial.println(). Das ln dahinter bedeutet, dass danach eine neue Zeile begonnen wird. Den seriellen Monitor findet man in der IDE unter Werkzeuge und darin einfach unter Serieller Monitor.

Mit diesem Befehl endet auch das erste Projekt. Es ist nicht besonders interessant oder kompliziert, aber es beinhaltet viele Grundlagenbefehle, die nun klar sind und in den folgenden Anwendungen ständig verwendet werden.

Anwendung 2: Die Wetterstation mit LCD-Display

Die zweite Anwendung wird nun schon etwas umfangreicher und es werden mehrere sehr wichtige Funktionen des Arduino vorgestellt. Diesmal wird eine Wetterstation konstruiert, die die Temperatur, Luftdruck und Höhe über dem Meeresspiegel ausgibt. Außerdem zeigt die Station die höchste und die niedrigste Temperatur an, die seit dem Start des Arduinos gemessen wurde. Die Temperaturwerte werden außerdem auf dem EEPROM, also dem Dauerspeicher des Arduinos, gespeichert, damit diese bei einem Neustart des Arduino nicht verloren gehen. Alle fünf Sekunden wechseln die dargestellten Werte auf dem Display. Es werden einmal die aktuelle Temperatur, die Höhe über dem Meeresspiegel und der Luftdruck dargestellt und nach fünf Sekunden die aktuelle Temperatur, die niedrigste Temperatur und die höchste Temperatur. Als Sensor dient der BMP180, gesteuert wird die Messstation

von einem Arduino Uno und dargestellt werden alle Werte auf einem LCD-Display mit 20 Spalten und vier Zeilen. Angeschlossen werden der BMP180 sowie das LCD-Display über den sogenannten I2C-Bus. Dieses Bussystem besteht aus zwei bidirektionalen Leitungen, einmal der Datenleitung SDA und der Steuerungsleitung oder Taktleitung SDC. Dieses Bussystem nutzt das sogenannte Master-Slave-Verfahren, bei dem in unserem Fall der Arduino der Master ist und den BMP180 als Slave steuert. Man kann auch mehrere I2C-Geräte parallel miteinander verbinden, was in einer späteren Anwendung angewendet wird. Der Arduino Uno hat zwei I2C-Anschlüsse. Einmal bei A4 (SDA) und bei A5 (SDC) und dann die mit SCL und SDA gekennzeichneten Anschlüsse. Der BMP180 wird an A4 und A5 über I2C angeschlossen, dazu noch an Ground und an die 3,3 Volt Spannungsversorgung des Arduino.

Das LCD-Display wird an Ground und die 5-Volt Spannungsversorgung des Arduino angeschlossen und auch über I2C an SDA und SCL. Empfohlen wird ein LCD-Display, bei dem auf der Rückseite bereits alle Anschlüsse mit einem Anschlussbrett verlötet sind, damit dieses über I2C verwendet werden kann. Andernfalls ist der Verkabelungsaufwand bei einem LCD-Display sehr hoch.

Auf der Rückseite kann man auch die Helligkeit mit Hilfe der Justiervorrichtung im blauen Quadrat einstellen. Im Betrieb wechselt das  LCD-Display alle fünf Sekunden die dargestellten Werte.

Auch für dieses Projekt wird der komplette Programmcode zuerst vollständig auf den folgenden Seiten abgedruckt und dann werden alle neuen und wichtigen Befehle genau erklärt.

#include <Wire.h>

#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);

#include "EEPROM.h"

float Temperatur;

int Luftdruck;

int Hoehe;

float maxTemperatur;

byte maxTempvorKomma;

float maxTempnachKomma;

byte maxTempnachKomma2;

float EEPROMWert;

float EEPROMWertvor;

float EEPROMWertnach;

float minTemperatur;

byte minTempvorKomma;

float minTempnachKomma;

byte minTempnachKomma2;

float EEPROMWertmin;

float EEPROMWertvormin;

float EEPROMWertnachmin;

void setup() {

Serial.begin(9600);

lcd.init();

lcd.backlight();

bmp.begin();

}

void loop() {

Serial.println(Temperatur);

Serial.println(maxTemperatur);

if(Temperatur > maxTemperatur){

  EEPROM.write(0, maxTempvorKomma);

  EEPROM.write(1, maxTempnachKomma2);

}

if(Temperatur < minTemperatur){

  EEPROM.write(2, minTempvorKomma);

  EEPROM.write(3, minTempnachKomma2);

}

lcd.clear();

lcd.setCursor(7, 0);

lcd.print("BMP180");

lcd.setCursor(0,1);

lcd.print("Temperatur:");

lcd.setCursor(12,1);

lcd.print(Temperatur);

lcd.print("\xDF C");

lcd.setCursor(0,2);

lcd.print("Luftdruck:");

lcd.setCursor(11,2);

lcd.print(Luftdruck);

lcd.print(" hPa");

lcd.setCursor(0,3);

lcd.print("H\xEFhe:");

lcd.setCursor(11,3);

lcd.print(Hoehe);

lcd.print(" Meter");

delay(5000);

lcd.clear();

lcd.setCursor(5,0);

lcd.print("Temperatur");

lcd.setCursor(0,1);

lcd.print("Aktuell:");

lcd.setCursor(12,1);

lcd.print(Temperatur);

lcd.print("\xDF C");

lcd.setCursor(0,2);

lcd.print("Maximum: ");

lcd.setCursor(12, 2);

lcd.print(EEPROMWert);

lcd.print("\xDF C");

lcd.setCursor(0,3);

lcd.print("Minimum: ");

lcd.setCursor(12, 3);

lcd.print(EEPROMWertmin);

lcd.print("\xDF C");

delay(5000);

}

Nach der gleichen Logik funktioniert die Bedingung if (Temperatur < minTemperatur), wenn die aktuell gemessene Temperatur niedriger ist als die niedrigste gemessene Temperatur. Auch hier erfolgt eine Umwandlung von Float-Variablen in Byte-Variablen und eine Speicherung auf dem Dauerspeicher an den Stellen 2 und 3 sowie eine Aktualisierung der niedrigsten gemessenen Temperatur.

Nun müssen die Werte noch auf dem LCD-Display ausgegeben werden. Als erstes wird mit dem Befehl lcd.clear() der Displayinhalt komplett gelöscht. Danach wird die Position des Cursors festgelegt an die Stelle 7 in der obersten Zeile mit lcd.setCursor(7, 0) und mit dem Befehl lcd.print("BMP180") der Schriftzug BMP180 ausgegeben. Danach wird der Cursor an die erste Stelle der Zeile 2 gesetzt mit dem Befehl lcd.setCursor(0,1) und es wird die Temperatur ausgegeben mit lcd.print("Temperatur:"). Die restlichen Ausgaben auf dem LCD-Display erfolgen genau nach demselben Prinzip. Da jede Anzeige fünf Sekunden erscheinen und dann wechseln soll, muss auch hier eine Verzögerung von 5000 Millisekunden erzeugt werden mit dem Befehl delay(5000). Anders als bei dem millis()-Befehl, bei dem das Programm weiterhin ausgeführt wird während der Arduino die Millisekunden zählt, wird bei dem Befehl delay() das gesamte Programm angehalten. Aus diesem Grund ist die millis()-Funktion extrem nützlich für Programme, in denen keine Verzögerung auftreten darf. In dem vorliegenden Fall bedeutet es, dass die Temperatur nicht kontinuierlich, sondern nur alle zehn Sekunden gemessen wird, da jede Anzeige eine Verzögerung von fünf Sekunden aufweist.

Der restliche Programmcode funktioniert nach demselben Prinzip, da die gleiche Ausgabe auf dem LCD-Display nur mit anderen Werten erfolgt. Damit ist auch die Programmierung der zweiten Anwendung abgeschlossen.

Anwendung 3: Die Temperaturmessstation mit 2 Arduinos

In der dritten Anwendung wird eine Temperaturmessstation konstruiert, die aus zwei miteinander verbundenen Arduino Microcontrollerboards besteht. Ein Arduino misst die Temperatur und sendet den Wert an den anderen Arduino, der den gemessenen Wert dann auf einem LCD-Display ausgibt. Die beiden Arduinos werden per I2C verbunden wie auch der Sensor und das LCD-Display.

Die Verkabelung erfolgt im Prinzip wie in der vorherigen Anwendung. Der einzige Unterschied liegt darin, dass der Sensor und das LCD-Display nicht an einem Arduino angeschlossen sind, sondern an zwei Arduinos. Benötigt werden für diese Anwendung ein Arduino Uno und ein Arduino Mega2560 sowie ein BMP180 und ein LCD-Display mit 4 Zeilen und 20 Spalten.

Der Arduino Uno wird dann einfach mit dem Arduino Mega2560 mit zwei Kabeln an dem I2C-Bus verbunden. Die Anschlüsse sind auf beiden Microcontrollern klar beschriftet.

Der BMP180 wird am Arduino Uno an den Anschlüssen A4 und A5 angeschlossen und mit 3,3 Volt versorgt.

Die Anschlüsse des LCD-Displays sind aus der letzten Anwendung bereits bekannt und diese werden einfach mit dem Arduino Mega2560 verbunden.

Nun muss nicht nur ein Arduino, sondern beide programmiert werden. Wichtig ist, dass immer ein Arduino als Master und einer als Slave fungiert. Mit diesem Vorwissen beginnt nun die Programmierung. Als erstes wird der Sender programmiert, in diesem Fall also der Arduino Uno. Aus dem folgenden Programmcode werden alle Neuheiten wieder erklärt, der Rest wird vorausgesetzt.

#include <Wire.h>

#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

float t;

float Temp;

int Tempsenden;

void setup() {

Serial.begin(9600);

Wire.begin();

bmp.begin();

}

void loop() {

Wire.beginTransmission(8);

Wire.write(Tempsenden);

Wire.endTransmission();

}