Fingerprint an einem ESP8266

tööö

@Ralla66
Ich habe son Teil hier:

Bisher messe ich damit immer nur, ob ich richtig gelötet habe. Auf 200 Ohm stellen und prüfen, ob was durchgeht. Was muss ich damit machen, um zu messen, wieviel Spannung anliegt? Sorry für die Anfängerfragen. ;-)

Levelshifter ist bidirektional, ja. Aber woher nehme ich die 5Volt, wenn der NodeMCU keine 5Volt liefert? Und wenn er 5Volt am VU-Pin liefert, dann bräuchte ich keine Levelshifter mehr, oder? Irgendwie ist da gerade ein Knoten im Kopf.

Dann habe ich also die TX und RX Pins schonmal richtig mit dem Levelshifter verbunden. Immerhin etwas. 😉

Ralla66

Teste mal das Multimeter an einer 1,5 Volt Batterie.
Wählst du Max 20 Volt Gleichspannung.

Wenn ok dann NodeMCU VU nach NodeMCU GND messen.

Wenn Vu nicht 5 Volt hat eine neue NodeMCU für 3 Euro zum gegen testen bestellen.
Macht nicht nicht Arm, aber läßt dich besser schlafen. :-)

Timmerx

Hallo Leute,

ich habe jetzt meinen Fingerprintsensor an einem Wemos D1 am Laufen.
Jetzt habe ich versucht die Finger #ID per MQTT an den IO Broker zu übertragen, leider hackts hier.


#include <Adafruit_Fingerprint.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(14, 12, false, 128);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// Update these with values suitable for your network.

const char* ssid = "Fritzbox";
const char* password = "Passwort";
const char* mqtt_server = "192.168.1xx.xx";



WiFiClient Fingerprint;
PubSubClient client(Fingerprint);

// Ab hier Setup programmieren WICHTIG VOR DEM AUFSPIELEN SERIAL MONITOR EINSCHALTEN FÜR IP ADDRESSE
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................

char msg[50];

int Blau=13;
//int TMP36 = A0; //Der Sensor soll am analogen Pin A0 angeschlossen werden. Wir nennen den Pin ab jetzt "TMP36"
int FingerMQTT;
//int temperatur = 0; //Unter der Variablen "temperatur" wird später der Temperaturwert abgespeichert.
//int t=500;

void setup() {  

  
  pinMode(Blau, OUTPUT);
  Serial.begin(9600);
  while (!Serial);  // For Yun/Leo/Micro/Zero/...
  delay(100);
  Serial.println("\n\nAdafruit finger detect test");

  // set the data rate for the sensor serial port
  finger.begin(57600);
  
  if (finger.verifyPassword()) {
    Serial.println("Fingerabdrucksensor gefunden!");
  } else {
    Serial.println("Fingerabdrucksensor nicht gefunden! :(");
    while (1) { delay(1); }
  }
  
            {
  finger.getTemplateCount();
  Serial.print("Sensor beinhaltet "); Serial.print(finger.templateCount); Serial.println(" Abdrücke");
  Serial.println("Warte auf bekannten Finger...");
              }
  

// Bis hier geht das Setup
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
            {
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
            }

}

void setup_wifi() {

  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println(); 
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");

    
// Arduino (Client-Gerät) Bezeichnung im IO Broker
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
   
    if (client.connect("Fingerprint")) {
      
// Arduino (Client-Gerät) Bezeichnung im IO Broker
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
      Serial.println("connected");
         } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}
// Ab hier beginnt das Programm
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................

void loop()                      // run over and over again
{
  getFingerprintIDez();
  delay(50);            //don't ned to run this at full speed.
}

uint8_t getFingerprintID() {
  uint8_t p = finger.getImage();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println("No finger detected");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }

  // OK success!

  p = finger.image2Tz();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  
  // OK converted!
  p = finger.fingerFastSearch();
  if (p == FINGERPRINT_OK) {       
   
    Serial.println("Found a print match!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_NOTFOUND) {
    Serial.println("Did not find a match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }   
  
  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID); 
  Serial.print(" with confidence of "); Serial.println(finger.confidence); 
 
  return finger.fingerID;
}

// returns -1 if failed, otherwise returns ID #
int getFingerprintIDez() {
  uint8_t p = finger.getImage();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.image2Tz();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.fingerFastSearch();
  if (p != FINGERPRINT_OK)  return -1;
FingerMQTT = finger.fingerID; 

{
if (finger.fingerID == 1) 
digitalWrite(LED_BUILTIN, HIGH);
delay (3000);
digitalWrite(LED_BUILTIN, LOW);
}

{
if (finger.fingerID == 10)  
digitalWrite(Blau, HIGH);
delay (1000);
digitalWrite(Blau, LOW);
}



  // found a match!
  Serial.print("ID #"); Serial.print(finger.fingerID); 
  Serial.print(" mit einer Genauigkeit von "); Serial.println(finger.confidence);
  Serial.println(FingerMQTT);
  return finger.fingerID;
  





// Bis hier geht das Programm
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
// Ab hier begint die Übertragung an den IO Broker

  if (!client.connected()) {
    reconnect();
  }
  client.loop();

     snprintf (msg, 75, "%ld", FingerMQTT);            // Der Wert hinter >>"%ld", <<(KOMMA) wird an den IO Broker übertragen  
     client.publish("ID", msg);                      // Name "so heißt der WERT" im IO Broker
 
}

// Bis hier geht die Übertragung an den IO Broker
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................
//.......................................................................................................................

SBorg

Ich habe verschiedene NodeMCUs und die sind unterschiedlich. Mal sind die 5V-Pins mit dem µUSB verbunden, mal nicht... :confused:
Da hilft nur anschließen und messen. Du brauchst für den Levelshifter zumindest beide (5V und 3.3V) Spannungen.

@Timmerx welchen MQTT nutzt du, ioBroker, mosquitto,...? Ist der wirklich ohne Usernamen und Passwort erreichbar?

tööö

@SBorg sagte in Fingerprint an einem ESP8266:

Da hilft nur anschließen und messen. Du brauchst für den Levelshifter zumindest beide (5V und 3.3V) Spannungen.

Ja, nur wo nehme ich die 5Volt her, wenn es der NodeMCU nicht liefert? Brauche ich dann noch zusätzlich eine externe Stromversorgung nur für den Levelshifter?

SBorg

Ja, denn ohne 5V läuft der nicht.
Du könntest aber auch ein (altes) USB-Kabel opfern. Typ A auf xxx
xxx-Stecker schneidest du ab und isolierst das Kabel ab.

rot = 5 Volt
schwarz = GND
(grün + weiß sind die Datenadern)

Dann kannst du rot 5V mit Vin verbinden (=NodeMCU hat Strom) und gleichzeitig den HV vom Levelshifter anschließen. schwarz logischerweise an einen GND und die 3.3V LV für den Levelshifter und den FP hast du auch gleich.

tööö

@SBorg
Ahh ok, wenn ich das also mit dem USB-Kabel an VIN mache, dann brauche ich nicht mehr an den USB-Anschluss vom NodeMCU anschließen, weil er dann durch den VIN-Port schon Strom bekommt, richtig?

Das klingt logisch und würde mir auch gefallen, bevor ich zwei Steckdosen dafür opfern muss. 😉

Heißt dann aber auch, dass ich den Fingerprint dann am VU anschließen kann, weil da ja dann auch 5Volt rauskommen...also brauche ich dann keinen Levelshifter mehr, oder?

Werde das nachher mal messen, was am VU wirklich rauskommt. Wobei ich glaube, dass ich den Fingerprint schonmal am VU-Pin hatte, aber mal schauen. Kann auch sein, dass ich den einen oder anderen NodeMCU geschrottet habe, aber dann teste ich nochmal mit einem frischen. Habe ein paar auf Lager. 😉

Ralla66

Den Levelshifter brauchst du noch.
Schau dir das Bild an.
Geschrottet kommt dem am nächsten :-)
Der sollte an VU 5 Volt haben.

Hansi1234

Kleine Zwischenfrage. Warum nehmt ihr nicht einen UART USB Stecker?

link text

Ralla66

Das ist bei den meisten NodeMCU mit an Board über Mini Usb.
TTL <-> RS232

tööö

Nun wollte ich die Spannung messen und mein Multimeter hat sich verabschiedet...oh man. Habe es mal aufgeschraubt, weil ich dachte, dass nur die Batterie leer ist, aber nee...irgendwas ist da drin verschmort. Also den "Lichttest" gemacht. Beim Anschluss an VU ist der Fingerprint tatsächlich heller als an 3,3V, gutes Zeichen also erstmal. ;-)

Dann habe ich das nach deinem ersten Bild angeschlossen. Mal ne Frage nebenbei, wie lötet man sowas dann eigentlich, wenn mehrere Leitungen an einen Pin gehen? Mache ich da eine Sammelstelle für alle Kabel, die zu einem Pin - beispielsweise GND - gehen und verbinde diese mit einem großen Lötkleks oder gibt es da schönere Möglichkeiten?

@Ralla66 sagte in Fingerprint an einem ESP8266:

Mit dem Blank-Sketch und der SFG-Demo funktioniert es nun einwandfrei, aaaaaber....es gibt immer ein aber. ;-)
Mache ich den enroll-Sketch drauf, schreibt er wieder "did not found fingerprint", ich bekomm wirklich langsam die Krise, so kurz vorm Ziel doch wieder nichts.

Mit dem blank-Sketch verbinde ich RX zu RX und TX zu TX (also wie auf dem Bild über den Levelshifter) und das funktioniert dann in der SFG-Demo, aber mit dem enroll-Sketch immer "not found", egal, wo ich TX und RX anschließe und was ich im Quellcode einstelle (Hardware- oder Softwareserial).

Hier nochmal der Code, den ich verwende (ist ja der aus der Bibliothek, nur die Pins angepasst):

/*************************************************** 
  This is an example sketch for our optical Fingerprint sensor

  Designed specifically to work with the Adafruit BMP085 Breakout 
  ----> http://www.adafruit.com/products/751

  These displays use TTL Serial to communicate, 2 pins are required to 
  interface
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include <Adafruit_Fingerprint.h>

// On Leonardo/Micro or others with hardware serial, use those! #0 is green wire, #1 is white
// uncomment this line:
//#define mySerial Serial1

// For UNO and others without hardware serial, we must use software serial...
// pin #2 is IN from sensor (GREEN wire)
// pin #3 is OUT from arduino  (WHITE wire)
// comment these two lines if using hardware serial
#include <SoftwareSerial.h>
SoftwareSerial mySerial(5, 4);
//SoftwareSerial mySerial(2, 3);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

uint8_t id;

void setup()  
{
  Serial.begin(9600);
  while (!Serial);  // For Yun/Leo/Micro/Zero/...
  delay(100);
  Serial.println("\n\nAdafruit Fingerprint sensor enrollment");

  // set the data rate for the sensor serial port
  finger.begin(57600);
  
  if (finger.verifyPassword()) {
    Serial.println("Found fingerprint sensor!");
  } else {
    Serial.println("Did not find fingerprint sensor :(");
    while (1) { delay(1); }
  }
}

uint8_t readnumber(void) {
  uint8_t num = 0;
  
  while (num == 0) {
    while (! Serial.available());
    num = Serial.parseInt();
  }
  return num;
}

void loop()                     // run over and over again
{
  Serial.println("Ready to enroll a fingerprint!");
  Serial.println("Please type in the ID # (from 1 to 127) you want to save this finger as...");
  id = readnumber();
  if (id == 0) {// ID #0 not allowed, try again!
     return;
  }
  Serial.print("Enrolling ID #");
  Serial.println(id);
  
  while (!  getFingerprintEnroll() );
}

uint8_t getFingerprintEnroll() {

  int p = -1;
  Serial.print("Waiting for valid finger to enroll as #"); Serial.println(id);
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      break;
    default:
      Serial.println("Unknown error");
      break;
    }
  }

  // OK success!

  p = finger.image2Tz(1);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  
  Serial.println("Remove finger");
  delay(2000);
  p = 0;
  while (p != FINGERPRINT_NOFINGER) {
    p = finger.getImage();
  }
  Serial.print("ID "); Serial.println(id);
  p = -1;
  Serial.println("Place same finger again");
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.print(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      break;
    default:
      Serial.println("Unknown error");
      break;
    }
  }

  // OK success!

  p = finger.image2Tz(2);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  
  // OK converted!
  Serial.print("Creating model for #");  Serial.println(id);
  
  p = finger.createModel();
  if (p == FINGERPRINT_OK) {
    Serial.println("Prints matched!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_ENROLLMISMATCH) {
    Serial.println("Fingerprints did not match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }   
  
  Serial.print("ID "); Serial.println(id);
  p = finger.storeModel(id);
  if (p == FINGERPRINT_OK) {
    Serial.println("Stored!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_BADLOCATION) {
    Serial.println("Could not store in that location");
    return p;
  } else if (p == FINGERPRINT_FLASHERR) {
    Serial.println("Error writing to flash");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }   
}

Anscheinend funktioniert ja an meiner NodeMCU HardwareSerial, sonst würde es die SFG-Demo nicht erkennen und würde auch nicht funktionieren, oder? Dann müsste mein enroll-Sketch doch folgendermaßen aussehen (und auch funktionieren):

// On Leonardo/Micro or others with hardware serial, use those! #0 is green wire, #1 is white
// uncomment this line:
#define mySerial Serial1

// For UNO and others without hardware serial, we must use software serial...
// pin #2 is IN from sensor (GREEN wire)
// pin #3 is OUT from arduino  (WHITE wire)
// comment these two lines if using hardware serial
//#include <SoftwareSerial.h>
//SoftwareSerial mySerial(5, 4);
//SoftwareSerial mySerial(2, 3);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

Ich hoffe, ihr habt nochmal so tolle Ideen, wir sind ja fast am Ziel. ;-)

Zumindest habe ich nun den Sinn und Zweck eines Levelshifters verstanden, braucht man sicher öfter bei manchen Sensoren. :-)

Ralla66

Heller ist gut also hast du wahrscheinlich 5 Volt.
Löten, Kabel so kurz wie möglich halten.
Sammelstelle eher nicht.
Blank nimmste nur zum anlernen am FP.
Schau noch mal oben mein Bild an.
Im Sketch eine Zeile anpassen, siehe Bild.
Das muß da rein :
SoftwareSerial mySerial(14, 12, false, 128);

Ganz nah am Erfolg :-)

tööö

@Ralla66
Kabel so kurz wie möglich ist klar, aber wie löte ich dann zwei Kabel an den GND-Pin vom NodeMCU? Die zwei Kabel müssen ja erstmal irgendwie verbunden werden und dann ein weiteres Kabel zum GND-Pin. Deshalb dachte ich an eine Sammelstelle, wo dann drei Kabel verbunden sind. Zwei, welche zur Sammelstelle hingehen und eins weg von der Sammelstelle zum GND-Pin.

Ja, mit dem Blank-Sketch kann ich anlernen, aber das kann das enroll-Skript doch auch. Aber leider funktioniert es mit deiner Zeile auch nicht. Damals hatte es mit 5 und 4 auch funktioniert, allerdings ohne Levelshifter, aber das wird nun nicht der Grund sein... :-/

@Ralla66 sagte in Fingerprint an einem ESP8266:

Ganz nah am Erfolg :-)

Ja, hoffentlich kriegen wir den Erfolg noch eingefangen. ;-)

Ralla66

Kriegste hin.
Ein dickeres Kabel vom GND Pin weg, daran deine Sammelstelle.
Erfolg noch eingefangen kriegste auch hin.
Wenn Finger angelernt lädst du die Fingerprint hoch mit
SoftwareSerial mySerial(14, 12, false, 128);
Dann ist der FP an der NodeMCU --> D5 = RX und D6 TX.
Nicht mehr RX / TX.

tööö

Also das ist alles sehr skuril. Es hat mit einem neuen NodeMCU wunderbar funktioniert, auch an GPIO5 und 4. Dann USB-Kabel abgezogen, wieder ran, resetten..."not found"...Sketch neu drauf..."not found"...Sketch nochmal drauf...läuft...aber er bringt wieder den Communication error, aber nicht wie sonst durchgängig, sondern immer mal zwischendurch.

Ich vermute, der Fingerprint hat irgendwie ne Macke. Könnt ihr einen empfehlen, der gut ist? Im Internet finde ich auch immer nur Anleitungen von Fingerprints, die rot leuchten, meiner leuchtet blau. Die Farbe ist mir ja egal, aber wundern tut es mich trotzdem. Selbst im Video auf aliexpress, wo ich ihn gekauft habe, leuchtet er rot, was ja auch nicht ganz zum Artikel passt.

Aber an dieser Stelle super vielen Dank für eure Geduld, denn im Großen und Ganzen funktioniert es ja nun. Nun werde ich erstmal alles schön detailliert in Fritzing zeichnen, damit das auch alles festgehalten ist. ;-)

Ralla66

Zumindest laufen bei mir die FPM10A ohne Probs.
Nur Rote Anschlußkabel.
Lolin NodeMCU die nächste Frage.
Mal ne andere NodeMCU nehmen ohne VU Anschluß.
Haben meine nicht.
FP immer schön an 5 Volt betreiben um so besser der Scan und die Auswertung.
Der Helligkeit wegen.
Zu Communication Error, meist ein Problem auf der Tx Rx Leitung.
Hier Pegel sauber ?

Jetzt noch nach IO Broker schaufeln per Mqtt wäre Cool.

:-)

tööö

@Ralla66
Ich habe an der Verkabelung ja nichts geändert. Anderen NodeMCU habe ich auch probiert. Ich kapiers selber nicht. Aber nun habe ich die Schnauze voll von diesem Fingerprint. 😉

Was meinst du mit „Pegel sauber“?

Per MQTT nach ioBroker ist die leichteste Übung, da übertrage ich schon Werte von anderen Sensoren. 😉

Ralla66

@tööö sagte in Fingerprint an einem ESP8266:

SoftwareSerial mySerial(5, 4);

Geh mal von 4 weg.
Hier nach :
http://stefanfrings.de/esp8266/
Zitat bei NodeMCU : D4 GPIO2 muss beim Start high sein, hat 12 kΩ Pull-Up Widerstand, flackert beim Start

Da könnte der Fehler liegen. Geh lieber auf 5, 6.

FP nach Mqtt würdest du wie machen ?

tööö

Ich habe eine Instanz vom Adapter MQTT installiert. Im Sketch dann folgenden Codeauszug:

Die relevanten Variablen (der Rest ergibt sich aus dem Code):

const char* ssid = "[DEIN SSID]";
const char* password = "[Dein WLAN-Passwort]";
const char* mqtt_server = "[IP vom ioBroker-Server";
const char* feuchtigkeitMQTT = "[Name, unter der der Wert im ioBroker im MQTT gespeichert werden soll]";
const char* zeitMQTT = "FeuchtigkeitPalmeObenZeit";
WiFiClient espClient;
PubSubClient client(espClient);
char charBuf[50];
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

Meine #includes:

#include <Smartdebug.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <WiFiClient.h>
#include <WiFiUdp.h>
#include <NTPClient.h>

wobei "Smartdebug.h" meine eigene Klasse ist, um schöner debuggen zu können und im fertigen Zustand die Debugausgaben eleganter ausschalten zu können, um Speicher zu sparen.

WLAN-Verbindung aufbauen:

void setup_wifi() {
  delay(10);
  DEBUG_PRINTLN();
  DEBUG_PRINT("Connecting to ");
  DEBUG_PRINTLN(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    DEBUG_PRINT(".");
  }

  randomSeed(micros());

  DEBUG_PRINTLN("");
  DEBUG_PRINTLN("WiFi connected");
  DEBUG_PRINTLN("IP address: ");
  DEBUG_PRINTLN(WiFi.localIP());
}

Falls die Verbindung zum MQTT-Server mal abbricht, wird sie hier wiederhergestellt:

void reconnect() {
  while (!client.connected()) {
    DEBUG_PRINT("Attempting MQTT connection...");
    String clientIdFeuchtigkeit = feuchtigkeitMQTT;
    if (client.connect(clientIdFeuchtigkeit.c_str())) {
      DEBUG_PRINTLN("connected");
    } else {
      DEBUG_PRINT("failed, rc=");
      DEBUG_PRINT(client.state());
      DEBUG_PRINTLN(" try again in 5 seconds");
      delay(5000);
    }
    
    String clientIdZeit = zeitMQTT;
    if (client.connect(clientIdZeit.c_str())) {
      DEBUG_PRINTLN("connected");
    } else {
      DEBUG_PRINT("failed, rc=");
      DEBUG_PRINT(client.state());
      DEBUG_PRINTLN(" try again in 5 seconds");
      delay(5000);
    }
  }
}

Und hier die setup-Funktion:

void setup() {
  timeClient.begin();
  // Offset für die Zeitzone einstellen
  // GMT +1 = 3600
  // GMT +8 = 28800
  // GMT -1 = -3600
  // GMT 0 = 0
  timeClient.setTimeOffset(7200);
  
  DEBUG_INIT(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  feuchtigkeit = analogRead(FEUCHTIGKEIT);

  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  DEBUG_PRINTLN(feuchtigkeit);
  String(feuchtigkeit).toCharArray(charBuf, 50);
  client.publish(feuchtigkeitMQTT, charBuf);

  while(!timeClient.update()) {
    timeClient.forceUpdate();
  }
  // Zeit kommt im folgendem Format
  // 2018-05-28T16:00:13Z
  formattedDate = timeClient.getFormattedDate();
  DEBUG_PRINTLN(formattedDate);

  int splitT = formattedDate.indexOf("T");
  dayStamp = formattedDate.substring(0, splitT);
  timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1);

  String zeitAusgabe = dayStamp + " - " + timeStamp;
  zeitAusgabe.toCharArray(charBuf, 50);
  client.publish(zeitMQTT, charBuf);  

  delay (2000);
  DEBUG_PRINTLN("Ich gehe nun in Schlafmodus für 60 Minuten (3600 Sekunden)");
  ESP.deepSleep(3600 * 1000000);
}

Ralla66

@tööö

Habe noch ein wenig gebastelt.
Der Fingerprintsensor sendet nun über den Wemos nach IO Broker mqtt.0 als Broker.
Der Sketch sendet nur die reine ID. Also 1 bis xxx.
Im Blockly werde ich später Rechte und Namen vergeben.
ID 1 bis 9 haben praktisch Admin Rechte dürfen alles.
ID 10 bis 19 werden begrenzte Rechte haben.
ID 20 bis, keine Rechte, nur lesen.
Wenn keine ID erkannt keine Schaltung in der Vis möglich, praktisch Partyschutz oder so.
Läuft soweit.
:-)

Ein Problem bleibt aber noch, nach kurzer Zeit bekomme ich ein Timeout im Log :
mqtt.0 2019-07-24 17:40:56.280 info Client [ESP8266Client] connection closed: timeout
Hier raus würde ich schließen -> info Client [ESP8266Client] connection closed -<
das der Client die Verbindung schließt ???
Liegt dies am Adapter mqtt.0 oder kann das aus dem Sketch kommen.
Kann mal bitte wer drüber schauen.
Sonst ist der Sonoff Adapter mein Broker,
das läuft noch nicht hier scheint der Topic falsch zu sein.
Kann was an den Einstellungen im Mqtt.0 Adapter falsch sein ?
Bin da nicht so fit mit.

Sketch:

/***************************************************
Fingerprint am Wemos D1 mini per MQTT nach IO Broker
****************************************************/

#include <Adafruit_Fingerprint.h>
#include <ESP8266WiFi.h> // Aus Wifi Mqtt
#include <PubSubClient.h> // Aus Wifi Mqtt

/****************************************************
Pinbelegung Fingerprint Sensor ist GND,Rx,TX,Vcc
Am Wemos Rx ist D6 also GPIO 12
Am Wemos Tx ist D5 also GPIO 14
*****************************************************/

SoftwareSerial mySerial(14, 12, false, 128);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

// Daten des eigenen Systems anpassen, Wifi und Mqtt Broker

const char* ssid = ""; // Netzwerknahme
const char* password = ""; // PW Netzwerk
const char* mqttServer = ""; // Broker IP
const int mqttPort = 1884; // Broker Port
const char* mqttUser = ""; // Broker Name
const char* mqttPassword = ""; // Broker Password

// Hier nichts ändern

char* mqttio = "12345"; // Broker Wert Vorbesetzung

WiFiClient espClient;
PubSubClient client(espClient);

void setup()
{
Serial.begin(9600);
while (!Serial); // For Yun/Leo/Micro/Zero/...
delay(100);
Serial.println("\n\nAdafruit finger detect test");

// set the data rate for the sensor serial port
finger.begin(57600);

if (finger.verifyPassword()) {
Serial.println("Found fingerprint sensor!");
} else {
Serial.println("Did not find fingerprint sensor :(");
while (1) { delay(1); }
}

finger.getTemplateCount();
Serial.print("Sensor contains "); Serial.print(finger.templateCount); Serial.println(" templates");
Serial.println("Waiting for valid finger...");

Serial.begin(9600); // Baud Wemos nach IDE Serieller Monitor

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.println("Connecting to WiFi..");
}
Serial.println("Connected to the WiFi network");

client.setServer(mqttServer, mqttPort);
client.setCallback(callback);

while (!client.connected()) {
Serial.println("Connecting to MQTT...");

if (client.connect("ESP8266Client", mqttUser, mqttPassword )) {

  Serial.println("connected");  

} else {

  Serial.print("failed with state ");
  Serial.print(client.state());
  delay(2000);

}

}

client.subscribe("Fingerprint_1");
client.publish("Fingerprint_1", "Test_1");

}

void callback(char* topic, byte* payload, unsigned int length) {

Serial.print("Message arrived in topic: ");
Serial.println(topic);

Serial.print("Message:");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}

Serial.println();
Serial.println("-----------------------");

}

void loop() // run over and over again
{
getFingerprintIDez();
delay(50); //don't ned to run this at full speed.
}

uint8_t getFingerprintID() {
uint8_t p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.println("No finger detected");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
return p;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
return p;
default:
Serial.println("Unknown error");
return p;
}

// OK success!

p = finger.image2Tz();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
return p;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
return p;
default:
Serial.println("Unknown error");
return p;
}

// OK converted!
p = finger.fingerFastSearch();
if (p == FINGERPRINT_OK) {
Serial.println("Found a print match!");
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error");
return p;
} else if (p == FINGERPRINT_NOTFOUND) {
Serial.println("Did not find a match");
return p;
} else {
Serial.println("Unknown error");
return p;
}

// found a match!
Serial.print("Found ID #"); Serial.print(finger.fingerID);
Serial.print(" with confidence of "); Serial.println(finger.confidence);

return finger.fingerID;
}

// returns -1 if failed, otherwise returns ID #
int getFingerprintIDez() {
uint8_t p = finger.getImage();
if (p != FINGERPRINT_OK) return -1;

p = finger.image2Tz();
if (p != FINGERPRINT_OK) return -1;

p = finger.fingerFastSearch();
if (p != FINGERPRINT_OK) return -1;

// found a match!
Serial.print("Found ID #"); Serial.print(finger.fingerID);
Serial.print(" with confidence of "); Serial.println(finger.confidence);

sprintf(mqttio,"%d",finger.fingerID);

 client.subscribe("Fingerprint_1"); 
   client.publish("Fingerprint_1",mqttio);
return finger.fingerID; 

client.loop();

}

Community Forum

NEWS

Fingerprint an einem ESP8266

Support us

732

32.4k

81.4k

1.3m