4. Embedded Projekte

4.1. WaterME - Smart Plants II

Als Erweiterung des SmartPlants-Projekts der letzten Woche hatten wir uns vorgenommen, die Messung und Aufzeichnung der Bodenfeuchtigkeit der Pflanzen in Home Assistant zu integrieren. Damit hat man alle Daten im eigenen Netzwerk und kann sie bequem über die Home Assistant Oberfläche einsehen. Außerdem haben wir, um das Einsehen der Feuchtigkeit bzw. Trockenheit zu erleichtern, einen Bewegungsmelder hinzugefügt, der bei Bewegung eine LED leuchten lässt. Die LED gibt dann an, ob die Pflanze gegossen werden muss oder nicht.

4.1.1. Home Assistant

Home Assistant ist eine Open-Source-Plattform zur Automatisierung von Smart Homes. Sie ermöglicht es, verschiedene Geräte und Dienste zu integrieren und zu steuern. Dabei kann man sowohl gekaufte Geräte als auch selbstgebaute Kombinationen von Microcontrollern und Sensoren einbinden. Home Assistant bietet eine Vielzahl von Integrationsmöglichkeiten und ist durch die große Community sehr flexibel und erweiterbar. [Home_Assistant]

In Anlehnung an das Projekt der letzten Woche haben wir uns entschieden, die Messdaten der Bodenfeuchtigkeit in Home Assistant zu integrieren. Dafür haben wir eine InfluxDB in Home Assistant eingerichtet, in der die Messdaten gespeichert werden. [HA_Influx]

InfluxDB

Zuerst mussten wir die Add-Ons InfluxDB und File Editor von Home Assistant installieren. Der File Editor ist notwendig, um die Konfigurationsdatei configuration.yaml in der Home Assistant Oberfläche verändern zu können, da die GUI-Einstellungen der InfluxDB nicht die Einstellungsmöglichkeiten bietet. Die Konfigurationsdatei haben wir dann entsprechend angepasst, um die Netzwerkadresse, Zugriffsrechte und den Datenbanknamen festlegen zu können.

In der InfluxDB selbst haben wir dann einen Benutzer und eine Datenbank erstellt, um diese später im Code des Microcontrollers verwenden zu können. [Influx_Tut1] Bei der Anpassung der Konfiguration traten jedoch einige Fehler auf. Die meisten von ihnen hatten mit den verschiedenen Versionen der Influx API zu tun. Die Version 2, die wir in der letzten Woche verwendeten, enthält bereits Buckets und bewerkstelligt die Authentifizierung über Tokens, die vergeben werden können. In Home Assistant ist jedoch nur die Version 1 verfügbar, die die Authentifizierung über Benutzername und Passwort vorsieht. Nachdem wir die Konfiguration entsprechend angepasst hatten, konnten wir die InfluxDB erfolgreich in Home Assistant einrichten. [Influx_GitHub]

Hier der relevante Ausschnitt aus der configuration.yaml:

influxdb:
    host: 192.168.178.80
    port: 8086
    database: home-assistant
    username: home-assistant
    password: thereturnnothing
    organization: home-assistant

4.1.2. Messung der Bodenfeuchtigkeit

Für die Bestimmung der Feuchtigkeit des Pflanzenbodens konnten wir auf die Erfahrungen des letzten Projektes zurückgreifen und das schon bestehende Skript weiterentwickeln. Zu der schon vorhandenen Funktionalität die Bodenfeuchtigkeit zu messen und in einer InfluxDB zu speichern, versetzen wir nun den ESP zwischen den Messungen in den Deep-Sleep Modus. Dieser Modus ermöglicht es dem ESP, sich für eine bestimmte Zeit komplett abzuschalten und somit den Energieverbrauch zu minimieren. Dabei wird die Aktivität des Microcontrollers soweit reduziert, dass nur noch die RTC (Real Time Clock) aktiv ist. So ist der ESP in der Lage nach einer bestimmten Zeit wieder „aufzuwachen“ und die Messung durchzuführen. [Deep_Sleep] Um den ESP in den Deep-Sleep Modus zu versetzen, wird der Befehl ESP.deepSleep(sleepTimeS * 1000000); verwendet. Dabei wird die Zeit in Sekunden angegeben, die der ESP schlafen soll. Fürs Testen haben wir uns zunächst für eine Zeit von 30 Sekunden entschieden. Im tatsächlichen Einsatz sollte eine Messung pro Stunde ausreichend sein. Um den ESP nach dieser Zeitspanne wieder aufzuwecken, muss nach dem Upload des Codes der RST-pin mit dem GPIO16 verbunden werden. Der RST-Pin ist während des Betriebs immer auf HIGH gesetzt, liegt dort ein LOW signal an, wird der ESP neu gestartet. Endet die Zeitspanne (Timer) sendet GPIO16 ein LOW Signal an den RST-Pin und so wacht der ESP auf. [Deep_Sleep]

Neben der Implementierung des Deep-Sleeps Modus haben wir auch die Messung der Bodenfeuchtigkeit optimiert. Hierzu ein Ausschnitt aus der loop()-Funktion:

void loop() {
    for (int i = 0; i < 5; i++){
        int aridityValue = analogRead(aridityPin);
        sensor.addField("Trockenheit", aridityValue);
        Serial.println(aridityValue);
        if (!client.writePoint(sensor)) {
        Serial.print("InfluxDB write failed: ");
        Serial.println(client.getLastErrorMessage());
        }
        sensor.clearFields();
        delay(1000 * 6);
    }

    ESP.deepSleep(30e6);
}

Wie hier zu sehen ist, werden fünf Messergebnisse im Abstand von 6 Sekunden gesammelt und in die InfluxDB geschrieben. Anschließend wird der ESP in den Deep-Sleep Modus versetzt. Dies soll eventuell auftretende Messfehler und Ungenauigkeiten abfangen.

Bei der Implementierung hatten wir die meisten Schwierigkeiten mit der InfluxDB. Da wir nun auf die integrierte Variante im Homeassistant angewiesen waren, mussten wir unseren Code an diese Version anpassen. Die Verbindung wie im letzten Projekt mittels Organisationsname, Bucket und Token herzustellen, war nicht mehr möglich. Stattdessen mussten wir uns mit einem Benutzernamen und Passwort authentifizieren. Im fertigen Code sieht dies wie folgt aus:

#define INFLUXDB_URL "http://192.168.178.80:8086/"
#define INFLUXDB_USERNAME "home-assistant"
#define INFLUXDB_PASSWORD "password"
#define INFLUXDB_ORG "home-assistant"

InfluxDBClient client(INFLUXDB_URL, INFLUXDB_ORG);
Point sensor("Bodenfeuchtigkeit");

void setup() {
    // ...

    client.setConnectionParamsV1(INFLUXDB_URL,  INFLUXDB_ORG, INFLUXDB_USERNAME, INFLUXDB_PASSWORD);
    //...
}

Im Vergleich zum letzten Projekt hat sich lediglich die initialisierung des Clients verändert und der nun zusätzlich nötige Methodenaufruf zum Ändern der Verbindungsparameter. So konnten wir den ESP auch mit der InfluxDB des Homeassistants verbinden und die Messergebnisse speichern.

4.1.3. Lebenszeichen der Pflanzen

Nachdem unser erster ESP nun kontinuierliche Daten an die Influx Datenbank sendet, können wir diese durch ein weiteres Skript abfragen. Konzeptionell soll eine LED Lampe Auskunft darüber geben, ob die Pflanze Wasser benötigt oder noch genug Wasser hat. Dieser Ansatz ist eine Alternative zu dem im letzten Bericht vorgestelltem Konzept mit Push-Notifications auf Smartphones. Die LED soll grundsätzlich ausgeschaltet sein. Falls ein Bewegungsmelder eine Person oder eine Bewegung erkennt, schaltet die LED Lampe auf grünes, gelbes oder rotes Licht. Für den Bewegungsmelder benutzen wir den günstigen HC-SR501 Sensor. Mit zwei Drehschaltern kann man direkt am Sensor die Empfindlichkeit, sowie die Haltedauer des Signales bestimmen [HC-SR501]. Für die Anzeigefarbe der LED wurde folgendes definiert:

• Grün: Pflanze hat ausreichend Wasser

• Gelb: Pflanze muss demnächst gegossen werden

• Rot: Pflanze benötigt dringend Wasser

Dabei wird jede Sekunde geprüft, ob eine Bewegung erkannt wurde. Wenn eine Bewegung detektiert wurde, bleibt die ausgegebene Farbe fünf Sekunden gleich, danach wird wieder neu überprüft, ob eine weitere Bewegung erkannt wurde.

void loop() {
    Serial.println("Reading..");
    Serial.println(digitalRead(16));
    while (digitalRead(16) == HIGH)
    {
        Serial.println("Bewegungsmelder aktiv.");
        FluxQueryResult result = client.query(query);
        if (result.next()) {
            long value = result.getValueByName("_value").getLong();
            Serial.println(value);
            if (value < 350) {
                Serial.println("Pflanze hat genügend Wasser :)");
                leds[0] = CRGB::Green;
                FastLED.show();
            } else if (value < 450) {
                Serial.println("Pflanze hat noch genügend Wasser, demnächst gießen.");
                leds[0] = CRGB::Yellow;
                FastLED.show();
            } else {
                Serial.println("Pflanze hat zu wenig wasser :(, bitte gießen.");
                leds[0] = CRGB::Red;
                FastLED.show();
            }
        } else {
            Serial.println("Could not retrieve data from InfluxDB query.");
            leds[0] = CRGB::BlueViolet;
            FastLED.show();
        }
        // Check if there was an error
        if(result.getError() != "") {
            Serial.print("Query result error: ");
            Serial.println(result.getError());
        }
        delay(1000 * 5);
    }
    leds[0] = CRGB::Black;
    FastLED.show();

    delay(1000);
}

Die Abfrage über die InfluxDB wird mithilfe der FluxQueryLanguage realisiert. Flux ist eine Open-Source Data Scripting Language, welche besonders für zeitbasierte Datenbanksysteme geeignet ist [Flux]. Der Aufbau der Query folgt einer Pipeline-Architektur mit verschiedenen Möglichkeiten zu filtern, sortieren oder spezifizieren.

String query = "from(bucket: \"home-assistant/autogen\")  \
|> range(start: -5m) \
|> filter(fn: (r) => r[\"_measurement\"] == \"Pflanze\") \
|> filter(fn: (r) => r[\"_field\"] == \"Trockenheit\") \
|> filter(fn: (r) => r[\"device\"] == \"ESP8266\") \
|> sort(columns: [\"_time\"], desc: true) \
|> limit(n:1, offset: 0)";

Für das Ansteuern der Lampe haben wir FastLED verwendet. Mit einer einfachen Initialisierung kann man aus verschiedenen Farben auswählen und die LED direkt ansteuern.

FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
leds[0] = CRGB::Green;
FastLED.show();

Im Laufe des Projektes hatten wir einige Probleme mit dem Bewegungsmelder. Zunächst hatten wir die Vermutung, dass die beiden Regler am Sensor nicht richtig eingestellt waren, da der Sensor die Bewegungen nicht zuverlässig und konstant erkannt hatte. Im weiteren stellte sich heraus, dass der Sensor auch bei abgestecktem Signalkabel vom Sensor zum ESP trotzdem noch ein Signal sendete. Durch weitere Recherche fanden wir heraus, dass der digitale Eingang als INPUT_PULLUP deklariert war und somit auch bei keiner Kabelverbindung ein positives Signal sendete. Mit folgender Zeile im Skript konnten wir dieses Problem erfolgreich lösen und den digitalen Eingang entgegengesetzt konfigurieren:

pinMode(16, INPUT_PULLDOWN_16);

4.2. Smart Plants mit Rust

Da wir ursprünglich geplant hatten, die Messung der Bodenfeuchtigkeit in Rust zu implementieren, wollten wir dies auch nachholen.

Als erstes haben wir Vorbereitungen getroffen, einen ESP32 mit Rust zu programmieren. VS Code bietet dafür die Erweiterung ESP-IDF an.

Vorbereitungen:

1. Rust installieren: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

2. nightly Rust installieren: rustup toolchain install nightly-2023-11-14 --component rust-src

3. Espressif Toolchain Dependencies installieren: sudo apt install llvm-dev libclang-dev clang libuv-dev libuv1-dev pkgconf python3-venv python-is-python3

4. cargo-espflash: cargo install cargo-espflash espflash ldproxy

5. Templates: cargo install cargo-generate

[ESP_Book]

Projekt erstellen: ESP-IDF bietet ein Template für Rust-Projekte. Dieses kann mit cargo-generate erstellt werden. - esp-template - no_std Template cargo generate esp-rs/esp-template - esp-idf-template - std Template cargo generate esp-rs/esp-idf-template cargo

Mit dem esp-idf-template wird ein Projekt mit folgender Struktur erstellt:

├── .cargo
│   └── config.toml
├── src
│   └── main.rs
├── .gitignore
├── build.rs
├── Cargo.toml
├── rust-toolchain.toml
└── sdkconfig.defaults

Die Übersetzung des Projektes war teilweise schwierig, da man für Rust entsprechende Crates benötigt, die die Funktionalität des ESP32 bereitstellen. Diese Crates sind jedoch nicht immer aktuell und es kann zu Problemen bei der Übersetzung kommen. Des Weiteren ist die Syntax von Rust komplexer, was die Implementierung erschwerte. Dennoch konnten wir die Implementierung der Bodenfeuchtigkeit in Rust größtenteils umsetzen.

use embedded_svc::wifi::{
    ClientConfiguration, Configuration, EmbeddedSvc, Status,
    AccessPointConfiguration,
};
use embedded_svc::utils::AtExit;
use esp_idf_hal::prelude::*;
use esp_idf_svc::netif::EspNetIfStack;
use influx_db_client::{Client, Point, Precision};
use std::sync::Arc;
use std::time::Duration;

const WIFI_SSID: &str = "WLAN_NAME";
const WIFI_PASSWORD: &str = "WIFI_PW";
const INFLUXDB_URL: &str = "http://HIER_IP_ADRESSE:8086";
const INFLUXDB_TOKEN: &str = "ADMIN_TOKEN";
const INFLUXDB_ORG: &str = "alex";
const INFLUXDB_BUCKET: &str = "plants";

#[entry]
fn main() -> ! {
    let peripherals = Peripherals::take().unwrap();
    let sysloop = EspSysLoopStack::new().unwrap();
    let netif_stack = Arc::new(EspNetIfStack::new().unwrap());
    let sys_loop_stack = Arc::new(EspSysLoopStack::new().unwrap());

    let mut wifi = EmbeddedSvc::default();
    let ap_config = AccessPointConfiguration::new(WIFI_SSID.into(), WIFI_PASSWORD.into());
    let client_config = ClientConfiguration::new().ap(ap_config);
    let status = wifi
        .configure(&sys_loop_stack, &client_config, &netif_stack)
        .and_then(|_| wifi.start())
        .expect("Failed to configure wifi");

    let influx_client = Client::new(INFLUXDB_URL, INFLUXDB_TOKEN);

    let sensor = Point::new("plant2");
    let mut humidity_pin = peripherals.pins.get_mut(0).unwrap();

    loop {
        let humidity_value = humidity_pin.read().expect("Failed to read humidity pin");
        let point = sensor
            .clone()
            .add_field("plant2", influx_db_client::Value::Integer(humidity_value as i64));

        if let Err(err) = influx_client.write_one(INFLUXDB_ORG, INFLUXDB_BUCKET, &point, Some(Precision::Seconds)) {
            eprintln!("InfluxDB write failed: {}", err);
        }

        std::thread::sleep(Duration::from_secs(2));
    }
}

Den Code zu kompilieren war jedoch nicht möglich, da die Crates entweder nicht aktuell waren oder es Konflitke mit anderen Crates gab. Die Probleme konnten bis zum Ende des Projektes nicht gelöst werden. Probleme waren unter anderem:

Mit dem Befehl cargo tree lassen sich die Abhängigkeiten der Crates anzeigen.

:emphasize-lines: 38

    └── influx_db_client v0.5.1
    ├── bytes v1.6.0
    ├── futures v0.3.30
    │   ├── futures-channel v0.3.30 (*)
    │   ├── futures-core v0.3.30
    │   ├── futures-executor v0.3.30
    │   │   ├── futures-core v0.3.30
    │   │   ├── futures-task v0.3.30
    │   │   └── futures-util v0.3.30 (*)
    │   ├── futures-io v0.3.30
    │   ├── futures-sink v0.3.30
    │   ├── futures-task v0.3.30
    │   └── futures-util v0.3.30 (*)
    ├── reqwest v0.11.27
    │   ├── base64 v0.21.7
    │   ├── bytes v1.6.0
    │   ├── encoding_rs v0.8.34
    │   │   └── cfg-if v1.0.0
    │   ├── futures-core v0.3.30
    │   ├── futures-util v0.3.30 (*)
    │   ├── h2 v0.3.26
    │   │   ├── bytes v1.6.0
    │   │   ├── fnv v1.0.7
    │   │   ├── futures-core v0.3.30
    │   │   ├── futures-sink v0.3.30
    │   │   ├── futures-util v0.3.30 (*)
    │   │   ├── http v0.2.12
    │   │   │   ├── bytes v1.6.0
    │   │   │   ├── fnv v1.0.7
    │   │   │   └── itoa v1.0.11
    │   │   ├── indexmap v2.2.6
    │   │   │   ├── equivalent v1.0.1
    │   │   │   └── hashbrown v0.14.5
    │   │   ├── slab v0.4.9 (*)
    │   │   ├── tokio v1.37.0
    │   │   │   ├── bytes v1.6.0
    │   │   │   ├── libc v0.2.154
    │   │   │   ├── mio v0.8.11
    │   │   │   │   └── libc v0.2.154
    │   │   │   ├── pin-project-lite v0.2.14
    │   │   │   └── socket2 v0.5.7
    │   │   │       └── libc v0.2.154

Hier verwendet das Crate „influx_db_client“ u.a. „mio“, was den oben gezeigten Fehler wirft.

Eine weitere Hürde war das Fehlen der Umgebungsvariable „openssl“, konnte man aber zügig mit dem Befehl export OPENSSL_DIR=/usr/include/openssl lösen.

Fazit Rust

• Embedded Rust hat bereits eine solide Community und man kann einiges darüber im Netz finden

• Rust-Projekt mit mehreren verschiedenen Abhängigkeiten zu bauen erfordert mehr Know-How als erwartet

Letzendlich war es dennoch ein Erfolg ein hello_world-Programm erfolgreich zu flashen und zu monitoren. Selbst das war nicht so trivial, wie es anfangs scheint.

4.3. RFID

RFID (Radio Frequency Identification) ist eine Technologie, die drahtlose Kommunikation verwendet, um Objekte oder Personen zu identifizieren und zu verfolgen. Diese Technologie basiert auf der Nutzung von Funkwellen zur Übertragung von Daten zwischen einem Lesegerät und einem RFID-Tag, der an einem Objekt befestigt ist.

4.3.1. Wichtige Fakten über RFID

• Bestandteile: RFID-Systeme bestehen aus Tags (Transpondern), Lesegeräten (Reader) und einer Antenne.

• Funktionsweise: RFID-Tags enthalten einen Mikrochip, der Daten speichert, und eine Antenne zur Kommunikation. Der Reader sendet ein Funksignal, das den Tag aktiviert und dessen Daten ausliest.

4.3.2. Tag-Typen

• Aktive Tags: Haben eine eigene Stromquelle (Batterie) und können größere Distanzen überbrücken (bis zu 100 Meter).

• Passive Tags: Keine eigene Stromquelle; werden durch das Signal des Readers aktiviert. Reichweite bis zu 10 Meter.

• Semi-Aktive Tags: Haben eine Batterie, die den Mikrochip versorgt, aber für die Kommunikation auf den Reader angewiesen ist. Reichweite liegt zwischen passiven und aktiven Tags.

4.3.3. Frequenzbereiche

• Niederfrequenz (LF): 30 - 300 kHz, Reichweite bis zu 10 cm, häufig verwendet für Zugangskontrollen und Tieridentifikation.

• Hochfrequenz (HF): 3 - 30 MHz, Reichweite bis zu 1 Meter, häufig verwendet für kontaktlose Zahlungssysteme und Bibliotheksmanagement.

• Ultrahochfrequenz (UHF): 300 MHz - 3 GHz, Reichweite bis zu 12 Meter, häufig verwendet in der Logistik und Bestandsverfolgung.

• Mikrowellen: 2.4 - 2.5 GHz und 5.8 GHz, Reichweite bis zu 10 Meter, häufig verwendet für Mautsysteme und Verkehrskontrolle.

4.3.4. Anwendungsbereiche

• Logistik und Bestandsmanagement: Verfolgung und Verwaltung von Waren und Gütern.

• Zugangskontrollen: Verwaltung von Zutrittsrechten zu Gebäuden und Bereichen.

• Kontaktlose Zahlungssysteme: NFC-basierte Zahlungslösungen.

• Tieridentifikation: Verfolgung und Verwaltung von Tieren.

• Bibliotheksmanagement: Verfolgung und Verwaltung von Büchern und Medien.

Frequenzbereich	Typische Frequenzen	Regionen	Reichweite
Niederfrequenz (LF)	125 kHz, 134.2 kHz	Weltweit	Bis zu 10 cm
Hochfrequenz (HF)	13.56 MHz	Weltweit	Bis zu 1 Meter
Ultrahochfrequenz (UHF)	433 MHz	Weltweit	Bis zu 12 Meter
Ultrahochfrequenz (UHF)	865-868 MHz	Europa	Bis zu 12 Meter
Ultrahochfrequenz (UHF)	902-928 MHz	USA	Bis zu 12 Meter
Ultrahochfrequenz (UHF)	950 MHz	Japan	Bis zu 12 Meter
Ultrahochfrequenz (UHF)	2.4-2.5 GHz	Weltweit	Bis zu 12 Meter
Mikrowellen	2.45 GHz, 5.8 GHz	Weltweit	Bis zu 10 Meter

Frequenzbereich	Transpondertypen	Standards	Anwendungen
Niederfrequenz (LF)	Passive	ISO 11784/11785	Zugangskontrollen, Tieridentifikation
Hochfrequenz (HF)	Passive	ISO 14443, ISO 15693, ISO 18092, ISO 28560	Kontaktlose Zahlungssysteme, Bibliotheksmanagement
Ultrahochfrequenz (UHF)	Passive, Aktive	ISO 18000-6C (EPC Gen 2), ISO 18000-63	Logistik, Mautsysteme
Mikrowellen	Aktive, Passive	ISO 18000-4, IEEE 802.11	Mautsysteme, Verkehrskontrolle

[RFID]

4.3.5. Reale Anwendung E-ZPass

E-ZPass ist in den USA ein Anbieter für Mautzahlungen. Dieses System funktioniert mittels aktiven RFID Transpondern, die über die 900 MHz Frequenz Daten austauschen. Dazu senden die Mautstationen, ein Start-Trigger Signal an die Empänger im Auto, die dann Ihre ID Übertragen, mit welcher dann die Abrechnung durchgeführt wird.

[E-ZPass]

4.4. NFC

Fakten:

• Frequenz: 13,56 MHz

• Distanz: Max. 10 cm

• Übertragungsrate: Max. 424 kBit/s

• Modis:

  • Reader/Writer Mode: Ein NFC-Gerät liest oder schreibt Daten auf ein NFC-Tag.

  • Peer-to-Peer Mode: Zwei NFC-fähige Geräte tauschen Daten direkt aus.

  • Card Emulation Mode: Ein NFC-Gerät verhält sich wie eine kontaktlose Smartcard.

NFC basiert auf NFC und kann im Gegensatz dazu sowohl aktiv-passiv, also aktiv-aktiv betrieben werden

[NFC]

Tab. 4.4.1 Vergleich von NFC, Bluetooth und RFID

Feature	NFC	Bluetooth	RFID
Reichweite	Bis zu 10 cm	Bis zu 100 m	Bis zu mehreren Metern
Übertragungsgeschwindigkeit	Bis zu 424 kbit/s	Bis zu 3 Mbit/s	Bis zu 640 kbit/s
Stromverbrauch	Sehr niedrig	Moderat bis hoch	Niedrig bis moderat
Verbindungsaufbau	Sofort	Paarung notwendig	Sofort
Anwendungsbereiche	Bezahlen, Zugangskontrolle, Datenaustausch	Audio, Datenaustausch, Peripherie	Logistik, Zugangskontrolle, Bestandsverwaltung

4.4.1. Beispielanwendung

In diesem Beispiel werden mittels ESP32 S3 Wroom1 und einem RC522 Board im 13,56 MHz Frequenzbereich RFID und NFC Tags ausgelesen.

Verwendete Pins:

• VCC -> 3.3V

• GND -> GND

• GND -> GND

• RST -> GPIO 22

• MISO -> GPIO 19

• MOSI -> GPIO 23

• SCK -> GPIO 18

• SDA -> GPIO 5

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN 22
#define SS_PIN 5

MFRC522 mfrc522(SS_PIN, RST_PIN);  // Create MFRC522 instance

void setup() {
    Serial.begin(115200);
    while (!Serial);
    SPI.begin();
    mfrc522.PCD_Init();

    Serial.println("RFID-RC522 Reader Initialized");
}

void loop() {
    if (!mfrc522.PICC_IsNewCardPresent()) {
        return;
    }

    if (!mfrc522.PICC_ReadCardSerial()) {
        return;
    }

    Serial.print("Card UID: ");
    for (byte i = 0; i < mfrc522.uid.size; i++) {
        Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
        Serial.print(mfrc522.uid.uidByte[i], HEX);
    }
    Serial.println();

    MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
    Serial.print("PICC Type: ");
    Serial.println(mfrc522.PICC_GetTypeName(piccType));

    mfrc522.PICC_HaltA();
}

4.5. Literaturangaben

[Deep_Sleep] (1,2)

ESP8266 Deep Sleep with Arduino IDE (NodeMCU) https://randomnerdtutorials.com/esp8266-deep-sleep-with-arduino-ide/ (abgerufen am 13.05.2024)

[HA_Influx]

InfluxDB Integration in Home Assistant https://www.home-assistant.io/integrations/influxdb/ (abgerufen am 13.05.2024)

[Influx_Tut1]

Home Assistant Influx DB Setup Tutorial https://pimylifeup.com/home-assistant-influxdb/ (abgerufen am 13.05.2024)

[Influx_GitHub]

GitHub Vergleichsprojekt https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/blob/master/src/InfluxDbClient.h (abgerufen am 13.05.2024)

[Home_Assistant]

Home Assistant Homepage https://www.home-assistant.io/ (abgerufen am 13.05.2024)

[ESP_Book]

The Rust on ESP Book https://docs.rust-embedded.org/book/ (abgerufen am 14.05.2024)

[Flux]

Flux documentation https://docs.influxdata.com/flux/v0/ (abgerufen am 14.05.2024)

[HC-SR501]

Bewegungssensor Anleitung https://cdn-reichelt.de/documents/datenblatt/A300/SEN-HC-SR501-ANLEITUNG-23.09.2020.pdf (abgerufen am 14.05.2024)

[RFID]

RFID https://de.wikipedia.org/wiki/RFID (abgerufen am 14.05.2024)

[NFC]

NFC https://de.wikipedia.org/wiki/Near_Field_Communication (abgerufen am 14.05.2024)

[E-ZPass]

E-ZPass https://roadwarrior.app/blog/e-zpass/ (abgerufen am 14.05.2024)