Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Off Topic
    4. Fingerprint an einem ESP8266

    NEWS

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    • Monatsrückblick - April 2025

    Fingerprint an einem ESP8266

    This topic has been deleted. Only users with topic management privileges can see it.
    • T
      tööö @Ralla66 last edited by

      @Ralla66
      Super, vielen Dank schonmal für deine Mühe.

      Merkwürdig ist ja schonmal, dass es bei dir mit 3,3Volt geht.

      Auf dem ESP habe ich blank mit SFG ja schon getestet, das ging leider nicht. Mit dem Arduino Nano hat es funktioniert.

      Ich glaube, ich bestelle mir einfach den gleichen FP, wie du nun hast, wenn der dann geht. 😉

      1 Reply Last reply Reply Quote 0
      • Ralla66
        Ralla66 Most Active last edited by Ralla66

        Das wird wenig nützen da dein Fingerprintsensor ja am Nano geht.
        Der Fehler liegt eher an der NodeMCU.
        Teste mal,
        NodeMCU per USB anschließen.
        Spannung FP holst du von der NodeMCU, 3,3 Volt und GND.
        RX TX FP nach RX TX NodeMCU oder mal tauschen. RX nach TX.
        Blank flashen der NodeMCU über IDE, hier achte darauf den richtigen ESP zu flashen.
        Wäre ja zu überlegen mal einen Wemos D1 zu bestellen.

        🙂

        1 Reply Last reply Reply Quote 0
        • T
          tööö last edited by

          Ok, werde ich mal testen mit dem blank und gebe dann Bescheid.

          1 Reply Last reply Reply Quote 0
          • SBorg
            SBorg Forum Testing Most Active last edited by

            Ich hätte da mal eine ganz blöde Vermutung...
            Witziger weise haben sie beim Ali (und nur genau von dem Sensor rede ich jetzt) nun ein Video hinzugefügt, und was sieht man da? Sie schließen ihn selbst an 5V und an einen UNO an.
            Am Nano läuft er bei @tööö ja auch. Was haben UNO + Nano gemeinsam? Richtig, diese laufen mit Atmegas und nicht mit ESPs. Was ist da der Hauptunterschied? Atmegas arbeiten mit 5V TTL, ESPs mit 3.3V...
            Da du den TTL-Pegel leider nicht messen kannst, wäre ev. die Lösung des Problems es doch mal mit einem simplen Level-Shifter für RXD/TXD zu probieren.

            T 1 Reply Last reply Reply Quote 0
            • T
              tööö @SBorg last edited by

              @SBorg Das ist ein sehr guter Hinweis und könnte wahrscheinlich echt die Lösung des Problems sein. Ich werde mir mal einen LevelShifter bestellen. 😊

              1 Reply Last reply Reply Quote 0
              • Ralla66
                Ralla66 Most Active last edited by Ralla66

                @tööö

                Fingerprint läuft auf dem Wemos D1 🙂
                FP hängt am Wemos 5 Volt.
                3,3 Volt teste ich noch.
                Auch getestet, meiner kann an 3,3 Volt betrieben werden.
                Im Sketch eine Zeile anpassen, siehe Bild.
                Das muß da rein :
                SoftwareSerial mySerial(14, 12, false, 128);

                RX TX passt jetzt auch.
                Für deine NodeMCU kannst du auch 12 und 14 nutzen.

                Läuft 😉

                Wemos_FP_2.jpg

                Hier noch meine Blank :

                void setup() {}
                void loop() {}

                Teste bitte zuerst ob die Blank mit 3,3 Volt am FP läuft !

                T 1 Reply Last reply Reply Quote 0
                • T
                  tööö @Ralla66 last edited by tööö

                  @Ralla66
                  So, habe mal den Blank-Sketch hochgeladen und dann im SFG den entsprechenden Port ausgewählt. Die Schaltfläche "Capture" hat funktioniert und liest meine Finger ein, dachte mir also erst "Jihhuuu, es funktioniert", aber nun kommt auch im SFG die Meldung "Receive package error".

                  Ich werde mir dann mal solche Leveshifter bestellen. Bekomme ich sicher noch irgendwo günstiger, da ich mir dann gleich mehrere bestelle. Wenn ich das richtig verstehe, brauche ich den ja immer, wenn ich Sensoren habe, die an 5V angeschlossen werden sollen.

                  Hast du vielleicht ne Seite, wo beschrieben steht, wie man den Levelshifter an den NodeMCU anschließt und den Sensor dann an den Levelshifter?

                  Besten Dank für deine Mühe! 🙂

                  [edit] Habe mir doch jetzt die bei ebay mal bestellt, sind ja 5 Stück und kommen dann auch schneller an. 😉

                  1 Reply Last reply Reply Quote 0
                  • T
                    tööö last edited by

                    Ich habe noch was gefunden, der NodeMCU hat einen VU-Pin, der ist wohl extra für 5V Sensoren gedacht. Wenn ich den FP daran anschließe, findet SFG den noch nicht mal. Nur mit 3,3V findet SFG den FP, aber damit funktioniert er ja nicht so richtig.

                    Ich hoffe einfach, dass das Thema dann mit dem Levelshifter erledigt ist. 😕

                    1 Reply Last reply Reply Quote 0
                    • SBorg
                      SBorg Forum Testing Most Active last edited by

                      Der Anschluss ist easy. 5V + GND dürfte klar sein, dann haben sie einen IN und einen OUT (teilweise auch anders beschriftet).
                      Bei einem "normalen" LS kommt an IN das Signal mit dem 5V Pegel, an OUT kommt es dann als 3.3V Pegel heraus.
                      Ein "biderektionaler" macht dann immer 5V <-> 3.3V bzw. auch umgekehrt.

                      In deinem Fall käme also IN an den FP (der scheint ja 5V TTL zu liefern) und OUT an den GPIO der NodeMCU. Das ganze insgesamt 2x, da du ja 1x TXD und 1x RXD brauchst.

                      T 1 Reply Last reply Reply Quote 0
                      • T
                        tööö @SBorg last edited by

                        @SBorg
                        So ganz sicher bin ich mir nicht, aber ist das soweit richtig? Aber wo schließe ich den HV vom Levelshifter an? Hab ja keine 5V am NodeMCU. Das VIN ist ja VoltageInput und das VU funktioniert irgendwie nicht, weil dann hätte es ja schon ohne Levelshifter funktionieren müssen, wenn aus VU eh 5Volt kommen, oder?

                        Fingerprint_Schaltplan.png

                        1 Reply Last reply Reply Quote 0
                        • Ralla66
                          Ralla66 Most Active last edited by Ralla66

                          Kaufe dir bitte ein Multimeter, muß nix tolles sein aber 5 Volt messen können.
                          Link:
                          https://www.pollin.de/p/multimeter-em393b-830739?&gclid=EAIaIQobChMIltTygIu64wIVF-d3Ch2MSg4FEAQYAiABEgLNO_D_BwE

                          Du scheinst eine Arduino NodeMCU zu haben da du einen VU Pin hast.
                          So wie ich gelesen habe wäre VU --> Voltage USB.
                          Also 5 Volt.

                          Du kannst testen ohne Multimeter,
                          Fingerprint versorgst du mit 3,3 Volt von der NodeMCU , merke dir die Helligkeit der Led am FP.
                          Dann an VU anschließen, Led muß heller am FP leuchten.
                          Oder anders, die Helligkeit Led 5 Volt am Arduino muß gleich sein NodeMCU VU.

                          Moderne PC liefern am USB Port 500 ma das sollte reichen.
                          Geht ja bei mir.
                          Entweder hast du zu wenig Ampere zur NodeMcu oder diese ist defekt.
                          VU muß 5 Volt sein.

                          Zum Levelshifter, je nach dem was du bestellt hast,
                          Bidirektional?
                          Dann wäre :
                          HV ist High Voltage ist 5 Volt woher auch immer.
                          Gnd von der gleichen Spannungsquelle.
                          Also 5 Volt von der NodeMCU VU, Gnd auch.
                          LV ist Low Voltage ist 3,3 Volt Volt woher auch immer.
                          Gnd von der gleichen Spannungsquelle.
                          Also 3,3 Volt von der NodeMCU, Gnd auch.
                          HV 1 bis HV 4 kannst du RX oder TX drauf legen.
                          HV 1 muß verbunden sein mit LV 1
                          HV 2 muß verbunden sein mit LV 2
                          usw siehste ja im Bild von dir.

                          T 1 Reply Last reply Reply Quote 0
                          • T
                            tööö @Ralla66 last edited by

                            @Ralla66
                            Ich habe son Teil hier:
                            C4AAF5FC-C878-42A9-A7C6-1B878C17EDF4.jpeg

                            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. 😉

                            1 Reply Last reply Reply Quote 0
                            • Ralla66
                              Ralla66 Most Active last edited by Ralla66

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

                              Test.jpg

                              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. 🙂

                              1 Reply Last reply Reply Quote 0
                              • Timmerx
                                Timmerx last edited by

                                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
                                //.......................................................................................................................
                                //.......................................................................................................................
                                //.......................................................................................................................
                                //.......................................................................................................................
                                
                                
                                1 Reply Last reply Reply Quote 0
                                • SBorg
                                  SBorg Forum Testing Most Active last edited by

                                  Ich habe verschiedene NodeMCUs und die sind unterschiedlich. Mal sind die 5V-Pins mit dem µUSB verbunden, mal nicht... 😕
                                  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 1 Reply Last reply Reply Quote 0
                                  • T
                                    tööö @SBorg last edited by

                                    @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?

                                    1 Reply Last reply Reply Quote 0
                                    • SBorg
                                      SBorg Forum Testing Most Active last edited by

                                      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 1 Reply Last reply Reply Quote 0
                                      • T
                                        tööö @SBorg last edited by

                                        @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. 😉

                                        1 Reply Last reply Reply Quote 0
                                        • Ralla66
                                          Ralla66 Most Active last edited by Ralla66

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

                                          FP.jpg

                                          FP2.jpg

                                          T 1 Reply Last reply Reply Quote 0
                                          • H
                                            Hansi1234 last edited by

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

                                            link text

                                            1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            896
                                            Online

                                            31.7k
                                            Users

                                            79.8k
                                            Topics

                                            1.3m
                                            Posts

                                            19
                                            126
                                            16723
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo