Zugriffskontrolle mit Nummernfeld, ESP32 und Shelly
In diesem Beitrag möchte ich dir zeigen, wie du eine Zugriffskontrolle mit einem Nummernfeld und einem ESP32 für einen Shelly bauen und programmieren kannst.
Den Shelly habe ich dir bereits in diversen Beiträgen vorgestellt, wie zum Beispiel.:
- Shelly Plus #1: Shelly Plus 1 Überblick
- Einsatzgebiete für den Shelly
- Shelly Plus #4: PIR Sensor am AddOn
AZ-Delivery D1 Board mit ESP32 Chip
Shelly Plus 1
Der Shelly verfügt über ein Relais, mit welchem wir Lasten bis zu 16A steuern können und wenn wir ein Schütz anklemmen, sogar noch größere. Mit diesem Relais können wir somit recht einfach ein Rolltor oder ein Schiebetor mit Motor steuern.
Ein Schütz, auch bekannt als Schaltschütz, dient zum Schalten von großen Lasten. Dabei wird mit einer kleinen Spannung eine große Last über einen elektromagnetischen Schalter gesteuert. Mithilfe dieses Bauteils können wir also mit einer kleinen Spannung einen großen Verbraucher schalten.
Möchtest du mehr über dieses Bauteil lesen, so empfehle ich dir den Beitrag von elektro4000.de.
Installationsschutz der Marke ABB
Ziel des Projektes - Zugriffskontrolle per Nummernfeld am ESP32 für Shelly
Das Ziel dieses kleinen Projektes ist es, eine Schaltung aufzubauen, mit welcher wir über ein Nummernfeld und einem ESP32 den Befehl an ein Shelly zum Aktivieren / Deaktivieren senden können. Die Stern-Taste soll mit der Funktion letzte Stelle löschen und die Raute-Taste mit Ausführen belegt werden.
Die Eingabe soll dabei über ein LCD-Display ablesbar sein.
https://youtu.be/BtRdL_shxT8
Benötigte Ressourcen für das Projekt
Wenn du das Projekt nachbauen möchtest, dann benötigst du:
- einen Shelly,
- einen ESP32,
- ein Nummernfeld,
- ein LCD-Display mit I2C Schnittstelle,
- diverse Breadboardkabel,
Der Shelly benötigt für den Betrieb eine Stromquelle von 12 V Gleichstrom oder 230 V Wechselstrom. Den ESP32 versorge ich in diesem Beispiel mit einem einfachen USB-Netzteil.
Aufbau der Schaltung - Nummernfeld am ESP32
Schließen wir zunächst das Nummernfeld und das LCD-Display an den ESP32 an.
Nachfolgend die Pinbelegungen am ESP32 für diese Schaltung:
BauteilESP323x4 KeypadPin 7GPIO12Pin 6GPIO14Pin 5GPIO27Pin 4GPIO16Pin 3GPIO17Pin 2GPIO25Pin 1GPIO26LCD-DisplayGNDGNDVCC5 VSDAGPIO21SCLGPIO22LED, grünGPIO19LED, rotGPIO18BuzzerGPIO23
Der Shelly kann wie bereits erwähnt Verbraucher bis zu 16A schalten, das reicht im Hausgebrauch für die meisten Für diesen Aufbau verwende ich eine Lampe, welche im späteren Verlauf aktiviert / deaktiviert wird.
Shelly Plus 1 mit Lampe
Die Lampe habe ich wie im Beitrag Shelly Plus #1: Shelly Plus 1 Überblick mit einer Steckdose dargestellt angeschlossen.
Relais per HTTP Request steuern
Das Relais lässt sich sehr einfach per HTTP Request steuern. Die Dokumentation zur Schnittstelle findest du auf der Seite https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/HTTP/.
Für das Absenden benötigen wir die IP-Adresse des Shellys diese findest du entweder in deinem Router oder in der Shelly App, wenn du das Gerät auswählst und dort die Geräteinformationen aufrufst.
Geräteinformationen zum Shelly
Zum Aktivieren des Relais müssen wir nur den Befehl im Browser oder per Postman ausführen.
http:///relay/0?turn=on
Wenn das Relais deaktiviert werden soll, so muss der Parameter "turn" lediglich auf den Wert "off" gestellt werden.
http:///relay/0?turn=off
Als Rückgabe erhält man ein JSON:
{"ison": true, "has_timer":false, "timer_started_at": 0, "timer_duration": 0.00, "timer_remaining": 0.00, "source": "http"}
Auf dem Display werden die verschiedenen Zustände und Meldungen angezeigt.
Im Fehlerfall soll zbsp. wenn der Shelly nicht erreichbar ist, die Meldung "Device not found" angezeigt werden. Wenn die WiFi Verbindung verloren gegangen ist, dann soll "missing WiFi" angezeigt werden.
Wenn eine gültige Pin eingegeben wurde, dann wird dem Benutzer "ACCESS GRANTED!" angezeigt.
In allen anderen Fällen erscheint die Textzeile zum Eingeben einer Pin.
Programmieren in der Arduino IDE
Wie man die 3x4 Matrix am Arduino programmiert, habe ich dir bereits im Beitrag Arduino Lektion 64: 3×4 Matrix Tastatur erläutert, diesen Beitrag verwende ich als Grundlage für das Programm.
erzeugen einer Ausgabe am LCD-Display
Zunächst binden wir die Bibliothek LiquidCrystal mit dem Befehl include ein. Diese kannst du über den internen Bibliotheksverwalter (1) der Arduino IDE installieren, indem du zunächst nach "LiquidCrystal" (2) suchst und dann die Schaltfläche "INSTALL" (3) am Eintrag "LiquidCrystal by Arduino, Adafruit" klickst. Wenn der Installationsprozess erfolgreich abgeschlossen ist, dann sollte der Text "INSTALLED" (4) angezeigt werden.
Installieren der Bibliothek LiquidCrystal über den Bibliotheksmanager der Arduino IDE
//Einbinden der Bibliotheken
//für das LCD-Display
#include
#include
//Es wird ein I2C Display mit 16 Zeichen,
//und zwei Zeilen verwendet.
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
//initialisieren des LCD-Displays
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Shelly Secure v1");
lcd.setCursor(0, 1);
lcd.print("PIN:");
}
/**
* Funktion wird fortlaufen ausgeführt.
**/
void loop() {
//bleibt leer
}
lesen der Tasten am 3x4 Keypad
Für die Programmierung des 3x4 Keypad benötigen wir wie auch beim LCD-Display eine Bibliothek, welche wir ebenso über den Bibliotheksmanager installieren. Dazu suchen wir nach "Keypad" (1) und wählen am Eintrag "Keypad by Mark Stanley, Alexander Brevig" die Schaltfläche "INSTALL" (2), wenn der Installationsprozess abgeschlossen ist, dann wird der Text "INSTALLED" (3) angezeigt.
Installieren der Bibliothek Keypad über den Bibliotheksmanager der Arduino IDE
//Einbinden der Bibliotheken
//für das 3x4 Keypad
#include
//Definieren des Keypads
const byte COLS = 3; //3 Spalten
const byte ROWS = 4; //4 Zeilen
//Pins von Links nach Rechts!
byte colPins = { 12, 14, 27 };
byte rowPins = { 16, 17, 25, 26 };
//definieren wo welche Taste liegt.
char KEYS = {
{ '#', '0', '*' },
{ '9', '8', '7' },
{ '6', '5', '4' },
{ '3', '2', '1' }
};
//Instanziieren eines Objektes vom Typ Keypad
//mit den zuvor definierten Werten
Keypad myKeypad = Keypad(makeKeymap(KEYS), rowPins, colPins, ROWS, COLS);
void setup() {
//begin der seriellen Kommunikation mit 115200 baud
Serial.begin(115200);
}
/**
* Funktion wird fortlaufen ausgeführt.
**/
void loop() {
//auslesen der gedrückten Taste
char key = myKeypad.getKey();
//Wenn eine Taste betätigt ist, dann enthält die Variable key einen Wert
if (key) {
Serial.println(key);
}
}
Aufbau einer WiFi-Verbindung und absenden eines HTTP Requests
Die Bibliotheken für den ESP32 wurden bereits mit dem Boardtreiber installiert, daher müssen wir diese lediglich mit dem include Befehl einbinden.
//Einbinden der Bibliotheken
//für die WiFi Verbindung des ESP32
#include
#include
//SSID & Passwort für das lokale WiFi
#define WIFI_SSID "***"
#define WIFI_PASSWORD "***"
void setup() {
//begin der seriellen Kommunikation mit 115200 baud
Serial.begin(115200);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(200);
}
//Wenn die Verbindung erfolgreich aufgebaut wurde,
//dann soll die IP-Adresse auf der seriellen Schnittstelle
//ausgegeben werden.
Serial.println("");
Serial.println("WiFi connected.");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
Serial.println();
}
/**
* Funktion wird fortlaufen ausgeführt.
**/
void loop() {
//bleibt leer
}
Der komplette Code für die Zugriffskontrolle am ESP32 mit Nummernfeld für den Shelly
Hier nun der komplette Code mit Kommentaren. Am Ende des Beitrages findest du einen Link, wo du diesen einfach als ZIP-Datei herunterladen kannst.
//Einbinden der Bibliotheken
//für das LCD-Display
#include
#include
//für das 3x4 Keypad
#include
//für die WiFi Verbindung des ESP32
#include
#include
//SSID & Passwort für das lokale WiFi
#define WIFI_SSID "****"
#define WIFI_PASSWORD "*****"
//Pins der LEDs
#define ledGruen 19
#define ledRot 18
//Pin des Buzzers
#define buzzer 23
//Konstanten für die PWM Signalerzeugung.
//Diese Werte werden benötigt damit ein
//Ton am Buzzer wiedergegeben werden kann.
const int CHANNEL = 0;
const int FREQUENZ = 2000;
const int RESOLUTIONBITS = 12;
const int TONE_FREQ = 600;
//Es wird ein I2C Display mit 16 Zeichen,
//und zwei Zeilen verwendet.
LiquidCrystal_I2C lcd(0x27, 16, 2);
//Definieren des Keypads
const byte COLS = 3; //3 Spalten
const byte ROWS = 4; //4 Zeilen
//Pins von Links nach Rechts!
byte colPins = { 12, 14, 27 };
byte rowPins = { 16, 17, 25, 26 };
//definieren wo welche Taste liegt.
char KEYS = {
{ '#', '0', '*' },
{ '9', '8', '7' },
{ '6', '5', '4' },
{ '3', '2', '1' }
};
//Instanziieren eines Objektes vom Typ Keypad
//mit den zuvor definierten Werten
Keypad myKeypad = Keypad(makeKeymap(KEYS), rowPins, colPins, ROWS, COLS);
//Index ab wo die Pineingabe startet.
//Auf dem Display soll in Zeile 2 zunächst
//das Wort "Pin:" stehen.
int keyIndex = 4;
//Index für die Anzahl der gedrückten Tasten
int pinIndex = 0;
//Auf dem Display sind lediglich 11 freie Stellen,
//dieses bedeutet das eine Pin maximal 11 Stellen haben soll/kann.
char pin = {};
//Die Pin welche später geprüft werden soll.
//Die Raute am Ende signalisiert das Ende der Pin.
const char PIN = { '1', '4', '6', '2', '#' };
//Feld zum speichern ob die Pin korrekt eingegeben wurde.
bool accessGranted = false;
//Die Adresse zum steuern des Relais.
//Hier musst du deine IP-Adresse eintragen!
//der Wert für den Key "turn" wird später im Code ergänzt.
String shellyRelaisAddress = "http://192.168.178.101/relay/0?turn=";
//Feld zum speichern des Relaisstatus
bool relaisStatus = false;
void setup() {
//begin der seriellen Kommunikation mit 115200 baud
Serial.begin(115200);
//Definieren das die Pins der LEDs
//und des Buzzers als Ausgang dient.
pinMode(ledGruen, OUTPUT);
pinMode(ledRot, OUTPUT);
pinMode(buzzer, OUTPUT);
//initial die rote LED aktivieren
//und die grüne deaktivieren
digitalWrite(ledRot, HIGH);
digitalWrite(ledGruen, LOW);
//konfigurieren des PWM Channels
ledcSetup(CHANNEL, FREQUENZ, RESOLUTIONBITS);
ledcAttachPin(buzzer, CHANNEL);
//starten der WiFi-Verbindung
initWiFi();
//initialisieren des LCD-Displays
lcd.init();
lcd.backlight();
//initialisieren des Displays und der Felder
init();
}
/**
* Funktion initialisiert die WiFi-Verbindung
* Wenn die Verbindung aufgebaut wurde, dann wird
* die IP-Adresse auf der seriellen Schnittstelle ausgegeben.
**/
void initWiFi() {
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(200);
}
//Wenn die Verbindung erfolgreich aufgebaut wurde,
//dann soll die IP-Adresse auf der seriellen Schnittstelle
//ausgegeben werden.
Serial.println("");
Serial.println("WiFi connected.");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
Serial.println();
}
/**
* Initialisiert das LCD-Display & die Felder
**/
void init() {
accessGranted = false;
keyIndex = 4;
pinIndex = 0;
//zurücksetzen der eingegeben Zeichen
pin = {};
//löscht das LCD-Display
lcd.clear();
reset();
digitalWrite(ledRot, HIGH);
digitalWrite(ledGruen, LOW);
}
/**
* Funktion zeigt auf dem LCD-Display
* in Zeile 1 den Text "Shelly Secure v1" an
* in Zeile 2 den Text "PIN:" gefolgt von
* den bisher eingegebenen Zeichen an.
**/
void reset() {
lcd.setCursor(0, 0);
lcd.print("Shelly Secure v1");
lcd.setCursor(0, 1);
lcd.print("PIN:");
//Schleife von 0 bis pinIndex,
//wobei pinIndex maximal 11 Stellen haben kann.
for (int i = 0; i < pinIndex; i++) {
//den aktuellen Cursor um eins nach links schieben
//das Zeichen aus dem Array an die Position schreiben
lcd.setCursor(i + 4, 1);
lcd.print(pin);
}
}
/**
* Wenn die eingegebene Pin ok ist dann wird,
* das Display gelöscht und
* die Textzeile "ACCESS GRANTED!" angezeigt.
**/
void executeAccessGranted() {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Shelly Secure v1");
lcd.setCursor(0, 1);
lcd.print("ACCESS GRANTED!");
//setzen des Feldes auf TRUE
accessGranted = true;
//aktivieren/deaktivieren des Relais
setShellyRelaisStatus();
}
/**
* Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde,
* dann wird der Status des Relais umgekehrt
* aus true wird false / aus false wird true
* und je nach Wert dann
* der Parameterwert "on" oder "off" angehängt.
* Die URL sowie der HTTP-ResponseCode wird
* für Debugausgaben in der seriellen Schnittstelle angezeigt.
**/
int setShellyRelaisStatus() {
if (WiFi.status() == WL_CONNECTED) {
String command = shellyRelaisAddress;
relaisStatus = !relaisStatus;
if (relaisStatus) {
command += "on";
digitalWrite(ledGruen, HIGH);
digitalWrite(ledRot, LOW);
} else {
command += "off";
init();
}
Serial.print("URL:");
Serial.println(command);
HTTPClient http;
http.setTimeout(1000);
http.begin(command.c_str());
int httpResponseCode = http.GET();
Serial.print("HTTP Code:");
Serial.println(httpResponseCode);
http.end();
//Ein HTTP-ResponseCode ungleich als 200 bedeutet ein Fehler.
//In diesem Fall wird es mit hoher Wahrscheinlichkeit sein das,
//der Shelly nicht erreichbar ist.
if (httpResponseCode != 200) {
//Ausgeben der Meldung auf dem Display
printMessage("Device
Read the full article
