Direkt zum Hauptbereich

WLAN-RFID-Reader in LOXONE einbinden

RFID-Tags sind inzwischen für wenige Euro zu bekommen und so liegt es nahe, RFID-Karten oder Schlüsselanhänger zur Steuerung verschiedener Programmabläufe  im eigenen Smarthome einzusetzen. Denkbar ist beispielsweise die Steuerung der Musikanlage via RFID-Karten (wie hier: https://youtu.be/AvCseOQidSw), die Steuerung und Verrechnung einer von mehreren Anwendern benutzten privaten Elektroauto-Ladesäule oder Kaffeemaschine.
Wichtig dabei zu wissen: RFID-Tags sind heute einfach zu klonen, somit eignen sie sich nicht ohne weitere Absicherung zur Steuerung des Zutritts in sensible Bereiche. (vgl. 1)
Das System könnte aber beispielsweise versteckt verbaut werden und über den Miniserver nur bei Anwesenheit eines Benutzers im Geofence mit Strom versorgt werden. Somit wäre der RFID-Leser nur verwendbar, wenn sich ein Bewohner dem Objekt nähert. Die Bootzeit des ESP8266 liegt bei etwa einer Sekunde - ist also nahezu verzögerungsfrei. Via Miniserver ließe sich zusätzlich via Ping überwachen ob der ESP angeschaltet ist - und somit eine externe Stromversorgung feststellen und Einbruch-Alarm auslösen.


Wir benötigen für unseren RFID-Reader nur einen kleinen Microcontroller in Form eines ESP8266 Prozessors und ein Mifare 522 RFID-Modul. Beides zusammen ist inklusive Versand aus China unter 10 Euro zu bekommen - beispielsweise bei AliExpress. (vgl. 2)
Als erstes muß das Modul an den ESP8266 angeschlossen werden und die Stromversorgung sichergestellt werden. 
Die nachfolgende, von mir in fritzing erstellte Skizze zeigt die nötigen Verbindungen:



Nach der Verkabelung geht es ans Aufspielen der Software - genauer um das Flashen der Firmware des ESPs. Hierfür kann unter Windows das Programm Arduino Create verwendet werden, das um ein Modul zur Kommunikation mit einem ESP8266 erweitert werden muß. Zusätzlich muss die Library für den 522er RFID-Leser sowie für die WLAN IP Kommunikation installiert werden (via "Manage Libraries").
Mit dem so konfigurierten Arduino Create kann über USB der ESP8266 mit unserem Programm ("Sketch") geflasht werden.

Hier der Sketch:



/*
 * ----------------------------------------------------------------------
 * Program to read new NUID from a PICC to serial und via UDP (WiFi)
 * ----------------------------------------------------------------------
 * https://circuits4you.com/2018/10/03/rfid-reader-rc522-interface-with-nodemcu-using-arduino-ide/
 * 
 * RC522 Interfacing with NodeMCU
 * 
 * Typical pin layout used:
 * ----------------------------------
 *             MFRC522      Node     
 *             Reader/PCD   MCU      
 * Signal      Pin          Pin      
 * ----------------------------------
 * RST/Reset   RST          D1 (GPIO5)        
 * SPI SS      SDA(SS)      D2 (GPIO4)       
 * SPI MOSI    MOSI         D7 (GPIO13)
 * SPI MISO    MISO         D6 (GPIO12)
 * SPI SCK     SCK          D5 (GPIO14)
 * 3.3V        3.3V         3.3V
 * GND         GND          GND
 */

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

const char* ssid = "SSID des WLANs";
const char* password = "WLAN passwort";
constexpr uint8_t RST_PIN = 5;     // Configurable, see typical pin layout above
constexpr uint8_t SS_PIN = 4;      // Configurable, see typical pin layout above
MFRC522 rfid(SS_PIN, RST_PIN);     // Instance of the class
MFRC522::MIFARE_Key key; 

// Init array that will store new NUID 
byte nuidPICC[4];

WiFiUDP Udp;
unsigned int localUdpPort = 5020;  // local port to listen on
char incomingPacket[255];  // buffer for incoming packets
char  replyPacket[] = "Hi there! Got the message :-)";  // a reply string to send back


void setup()
{
  Serial.begin(115200);
  SPI.begin(); // Init SPI bus
  rfid.PCD_Init(); // Init MFRC522 
  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF;
  }

  Serial.println(F("This code scan the MIFARE Classsic NUID."));
  Serial.println(F("Using the following key:"));
  printHex(key.keyByte, MFRC522::MF_KEY_SIZE);
  Serial.println("");
  Serial.printf("Connecting to %s ", ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println(" connected");

  Udp.begin(localUdpPort);
  Serial.printf("Now listening at IP %s, UDP port %d\n", WiFi.localIP().toString().c_str(), localUdpPort);
}


void loop()
{


  // Look for new cards
  if ( ! rfid.PICC_IsNewCardPresent())
    return;

  // Verify if the NUID has been readed
  if ( ! rfid.PICC_ReadCardSerial())
    return;

  Serial.print(F("PICC type: "));
  MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
  Serial.println(rfid.PICC_GetTypeName(piccType));

  // Check is the PICC of Classic MIFARE type
  if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&  
    piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
    piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
    Serial.println(F("Your tag is not of type MIFARE Classic."));
    return;
  }

  if (rfid.uid.uidByte[0] != nuidPICC[0] || 
    rfid.uid.uidByte[1] != nuidPICC[1] || 
    rfid.uid.uidByte[2] != nuidPICC[2] || 
    rfid.uid.uidByte[3] != nuidPICC[3] ) {
    Serial.println(F("A new card has been detected."));

    // Store NUID into nuidPICC array
    for (byte i = 0; i < 4; i++) {
      nuidPICC[i] = rfid.uid.uidByte[i];
    }
   
    Serial.println(F("The NUID tag is:"));
    Serial.print(F("In hex: "));
    printHex(rfid.uid.uidByte, rfid.uid.size);
    Serial.println();
    Serial.print(F("In dec: "));
    printDec(rfid.uid.uidByte, rfid.uid.size);
    Serial.println();
  }
  else Serial.println(F("Card read previously."));
    printHex(rfid.uid.uidByte, rfid.uid.size);       // Auch bekannte Karte wird ausgegeben
    Serial.println(F(""));

// ab hier eingefügt für RFID output
    Udp.beginPacket("192.168.0.1", 1234);            // IP und Port des LOXONE Miniservers
    Udp.write(rfid.uid.uidByte, rfid.uid.size);
    Udp.endPacket();
  

  // Halt PICC
  rfid.PICC_HaltA();

  // Stop encryption on PCD
  rfid.PCD_StopCrypto1();

}

/**
 * Helper routine to dump a byte array as hex values to Serial. 
 */
void printHex(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], HEX);
  }
}

/**
 * Helper routine to dump a byte array as dec values to Serial.
 */
void printDec(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], DEC);
  }
}

Nach dem Upload kann die serielle Ausgabe im Monitor des Arduino Create debugged werden. Funktioniert hier die Erkennung der Tags, kann in der LOXONE Config der Bereich virtuelle Eingänge ausgewählt werden und dann im UDP-Monitor die Ausgabe beobachtet werden. Hier wird nun die ID der Tags per UDP-Paket übertragen. Nun kann man einen virtuellen Eingang erstellen, mit der IP und Port des ESP8266. Darunter dann pro Tag einen Befehl bestehend aus der ID des Tags im Attribut "Befehlserkennung" und aktiviert die Option "als Digitaleingang verwenden".
Jetzt braucht man den virtuellen Befehl nur mehr mit seiner gewünschten Funktion/Logik verbinden.
Viel Spaß beim nachbauen!


Kommentare

  1. Hallo

    Ist es möglich in diesem Sketch auch die originalen Loxone RFID-Tag´s zu implementieren.

    Bei mir kommt jetzt die Fehlermeldung

    "PICC type: PICC compliant with ISO/IEC 14443-4
    Your tag is not of type MIFARE Classic."

    Würde mich über eine positive Antwort freuen.

    Lg

    Philipp

    AntwortenLöschen
    Antworten
    1. Hallo Philipp,

      die Hardware sollte alle RFID_Tags von Mifare unterstützen. Soweit ich sehe sind auch die LOXONE RFID Tags von Mifare, allerdings mit der aktuelleren Desfire Verschlüsselung.
      Der Sketch hier unterstützt nur die Classic Versionen.

      Ich würde an Deiner Stelle nach einem Sketch suchen, der Desifre Karten auslesen kann; wenn man den Auslese-Teil im Sketch oben dann mit einem passenden aus einem anderen Sketch ersetzt, sollte die Funktion gegeben sein. Kannst Du mit folgendem Sketch die Loxone Tags auslesen?
      https://arduino-projekte.webnode.at/meine-projekte/zugangskontrolle-mit-rfid-1/uid-sak-type/
      Liebe Grüße
      Nico

      Löschen

Kommentar veröffentlichen

Beliebte Posts aus diesem Blog

Überschussladen via LOXONE und Go-E Charger

Wer ein Elektroauto fährt und eine PV-Anlage betreibt wird vermutlich schnell den Wunsch verspüren das Auto mit seinem Überschussstrom zu laden, da man für eingespeisten Strom meist deutlich weniger erhält, als der bezogene Strom kostet und man mit PV-Strom bekanntlich 15 Zusatz PS gewinnt. Unser Hyundai Ioniq besitzt nur den kleinen 28kWh Akku und unsere PV-Anlage ist eine kleine Balkonanlage bestehend aus drei 250Wp Modulen. Je nach Akku und Solaranlage können die sinnvollen Schwellwerte für die Logik bei anderen Anlagen deswegen natürlich auch ganz anders aussehen. Zumeist bekommen wir bei schönem Wetter aus der 750Wp Anlage ca. 600 Watt Ertrag, der Hausverbrauch bei Anwesenheit liegt bei uns (incl. Allgemeinstrom fürs Haus, der über unseren Zähler läuft) bei etwa 450 Watt - große Mengen an eigenem PV-Strom bekommen wir also nicht ins Auto, bevor die Anlage nicht erweitert wird oder eine große Anlage am Hausdach möglich wird. Da bereits ein LOXONE Miniserver vorhanden ist und eine G

CarPC auf Raspberry-Pi Basis (3) - Stromversorgung

Nachdem wir die GPS-Daten schon verarbeiten können geht es langsam an den Einbau ins Auto - und dafür muß die Stromversorgung noch vorbereitet werden. Die Stromversorgung des Raspberry Pi ist wohl in der Praxis eine der größeren Hürden beim Einsatz im Auto: Will man den RPi sinnvoll als Fahrtenbuch, GPS-Tracker, oder Mediaplayer verwenden, muß er ohne Benutzereingriff jederzeit zu Verfügung stehen. Die meisten KFZ-Steckdosen sind glücklicherweise Zündungs-geschaltet - beim Einschalten geht also der Strom an, beim Ausschalten auch direkt wieder aus. Dies hat den Hintergrund, daß eine Dauerbeschaltung der Steckdose die Batterie leer saugen könnte. In der Folge kann man also den Raspberry Pi direkt an einen KFZ-USB Adapter betreiben - er schaltet sich beim starten automatisch an, wird aber beim Abschalten des Autos hart vom Strom genommen. Genau dies führt teilweise zur Stromunterbrechung exakt während eines Schreibvorgangs auf die SD-Karte und kann diese in ihrer Funktion beeinträchtig

Sonoff TH16 unter LOXONE einsetzen

Eine Steckdose per WLAN schalten oder Temperatur- und Verbrauchswerte von Geräten per WLAN in LOXONE überwachen? Dafür bieten sich die verbreiteten Sonoff Aktoren an, die nichtmal 20 Euro incl. Versand kosten. Es gibt zwar eine spezielle Firmware (HMlox) zur Integration in LOXONE, die aber leider nicht mit den Versionen Sonoff POW R2 oder Sonoff TH10 / TH16 kompatibel ist. Eigentlich wäre der Einsatz von MQTT angebracht, aber mangels entsprechenden Brokers setze ich momentan auf die Anbindung per Syslog / UDP. Hierfür muss der Sonoff mit einer aktuellen Version von Tasmota geflasht werden https://github.com/arendst/Sonoff-Tasmota/releases   - Stiftleiste anlöten - FTDI verbinden (3,3 Volt!) - Tasmota via Atom IDE aufspielen Sobald der Sonoff mit Tasmota versorgt ist und im WLAN hängt, lässt er sich per Weboberfläche schalten und auslesen. Nun müssen wir diese Zustände noch in die LOXONE bekommen: Die Weboberfläche eines mit Tasmota  geflashten Geräts ist simpel - aber mächti