From Chunky Peafowl, 1 Year ago, written in Plain Text.
Embed
  1. #include <Adafruit_Fingerprint.h>
  2. #define mySerial Serial1
  3.  
  4. Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
  5.  
  6. uint8_t getFingerprintEnroll();
  7. void printHex(int num, int precision);
  8.  
  9. void setup()
  10. {
  11.     Serial.begin(9600);
  12.     Serial.println("Adafruit Fingerprint sensor enrollment");
  13.  
  14.     // set the data rate for the sensor serial port
  15.     finger.begin(57600);
  16.  
  17.     if (finger.verifyPassword()) {
  18.         Serial.println("Found fingerprint sensor!");
  19.     } else {
  20.         Serial.println("Did not find fingerprint sensor :(");
  21.         while (1);
  22.     }
  23. }
  24.  
  25. void loop() {
  26.     ;
  27. }
  28.  
  29. void serialEvent() {
  30.     if (Serial.available()) {
  31.         char c = Serial.read();
  32.         if (c == '1')
  33.             getFingerprintEnroll();
  34.     }
  35. }
  36.  
  37.  
  38. uint8_t getFingerprintEnroll() {
  39.  
  40.     int p = -1;
  41.     Serial.print("Waiting for valid finger to enroll..");
  42.     while (p != FINGERPRINT_OK) {
  43.         p = finger.getImage();
  44.         switch (p) {
  45.             case FINGERPRINT_OK:
  46.                 Serial.println("Image taken");
  47.                 break;
  48.             case FINGERPRINT_NOFINGER:
  49.                 Serial.println(".");
  50.                 break;
  51.             case FINGERPRINT_PACKETRECIEVEERR:
  52.                 Serial.println("Communication error");
  53.                 break;
  54.             case FINGERPRINT_IMAGEFAIL:
  55.                 Serial.println("Imaging error");
  56.                 break;
  57.             default:
  58.                 Serial.println("Unknown error");
  59.                 break;
  60.         }
  61.     }
  62.  
  63.     // OK success!
  64.  
  65.     p = finger.image2Tz(1);
  66.     switch (p) {
  67.         case FINGERPRINT_OK:
  68.             Serial.println("Image converted");
  69.             break;
  70.         case FINGERPRINT_IMAGEMESS:
  71.             Serial.println("Image too messy");
  72.             return p;
  73.         case FINGERPRINT_PACKETRECIEVEERR:
  74.             Serial.println("Communication error");
  75.             return p;
  76.         case FINGERPRINT_FEATUREFAIL:
  77.             Serial.println("Could not find fingerprint features");
  78.             return p;
  79.         case FINGERPRINT_INVALIDIMAGE:
  80.             Serial.println("Could not find fingerprint features");
  81.             return p;
  82.         default:
  83.             Serial.println("Unknown error");
  84.             return p;
  85.     }
  86.  
  87.     Serial.println("Remove finger");
  88.     delay(500);
  89.     p = 0;
  90.     while (p != FINGERPRINT_NOFINGER) {
  91.         p = finger.getImage();
  92.     }
  93.     Serial.println("...");
  94.     p = -1;
  95.     Serial.println("Place same finger again");
  96.     while (p != FINGERPRINT_OK) {
  97.         p = finger.getImage();
  98.         switch (p) {
  99.             case FINGERPRINT_OK:
  100.                 Serial.println("Image taken");
  101.                 break;
  102.             case FINGERPRINT_NOFINGER:
  103.                 Serial.print(".");
  104.                 break;
  105.             case FINGERPRINT_PACKETRECIEVEERR:
  106.                 Serial.println("Communication error");
  107.                 break;
  108.             case FINGERPRINT_IMAGEFAIL:
  109.                 Serial.println("Imaging error");
  110.                 break;
  111.             default:
  112.                 Serial.println("Unknown error");
  113.                 break;
  114.         }
  115.     }
  116.  
  117.     // OK success!
  118.  
  119.     p = finger.image2Tz(2);
  120.     switch (p) {
  121.         case FINGERPRINT_OK:
  122.             Serial.println("Image converted");
  123.             break;
  124.         case FINGERPRINT_IMAGEMESS:
  125.             Serial.println("Image too messy");
  126.             return p;
  127.         case FINGERPRINT_PACKETRECIEVEERR:
  128.             Serial.println("Communication error");
  129.             return p;
  130.         case FINGERPRINT_FEATUREFAIL:
  131.             Serial.println("Could not find fingerprint features");
  132.             return p;
  133.         case FINGERPRINT_INVALIDIMAGE:
  134.             Serial.println("Could not find fingerprint features");
  135.             return p;
  136.         default:
  137.             Serial.println("Unknown error");
  138.             return p;
  139.     }
  140.  
  141.     // OK converted!
  142.     Serial.print("Creating model....");
  143.  
  144.     p = finger.createModel();
  145.     if (p == FINGERPRINT_OK) {
  146.         Serial.println("Prints matched!");
  147.     } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
  148.         Serial.println("Communication error");
  149.         return p;
  150.     } else if (p == FINGERPRINT_ENROLLMISMATCH) {
  151.         Serial.println("Fingerprints did not match");
  152.         return p;
  153.     } else {
  154.         Serial.println("Unknown error");
  155.         return p;
  156.     }
  157.  
  158.     p = finger.getModel();
  159.  
  160.     if (p == FINGERPRINT_OK) {
  161.         Serial.println("transferrring...");
  162.     } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
  163.         Serial.println("Communication error");
  164.         return p;
  165.     } else if (p == FINGERPRINT_UPLOADFEATUREFAIL) {
  166.         Serial.println("Transmission error");
  167.         return p;
  168.     } else {
  169.         Serial.println("Unknown error");
  170.         return p;
  171.     }
  172.  
  173.     // one data packet is 267 bytes
  174.     // in one data packet, 11 bytes are 'usesless' :D
  175.     uint8_t bytesReceived[534]; // 2 data packets
  176.     memset(bytesReceived, 0xff, 534);
  177.  
  178.     uint32_t starttime = millis();
  179.     int i = 0;
  180.     while (i < 534 && (millis() - starttime) < 20000) {
  181.         if (mySerial.available()) {
  182.             bytesReceived[i++] = mySerial.read();
  183.         }
  184.     }
  185.     Serial.print(i); Serial.println(" bytes read.");
  186.     Serial.println("decoding packet...");
  187.  
  188.     uint8_t fingerTemplate[512]; // the real template
  189.     memset(fingerTemplate, 0xff, 512);
  190.  
  191.     // filtering only the data packets
  192.     int uindx = 9, index = 0;
  193.     while (index < 534) {
  194.         while (index < uindx) ++index;
  195.         uindx += 256;
  196.         while (index < uindx) {
  197.             fingerTemplate[index++] = bytesReceived[index];
  198.         }
  199.         uindx += 2;
  200.         while (index < uindx) ++index;
  201.         uindx = index + 9;
  202.     }
  203.     for (int i = 0; i < 512; ++i) {
  204.         //Serial.print("0x");
  205.         printHex(fingerTemplate[i], 2);
  206.         //Serial.print(", ");
  207.     }
  208.     Serial.println("done.");
  209. }
  210.  
  211. void printHex(int num, int precision) {
  212.     char tmp[16];
  213.     char format[128];
  214.  
  215.     sprintf(format, "%%.%dX", precision);
  216.  
  217.     sprintf(tmp, format, num);
  218.     Serial.print(tmp);
  219. }

Replies to Untitled rss

Title Name Language When
Untitled Blush Guinea Pig cpp 1 Year ago.