LECTOR DE HUELLA

I. OBJETIVOS
 Armaremos el lector de huella programado por arduino.
II. MATERIALES
 Lector de huellas

 Arduino 1

III. INTRODUCCION

¿Qué es ARDUINO?

Arduino es una plataforma de desarrollo basada en una placa electrónica de hardware

libre que incorpora un microcontrolador re-programable y una serie de pines hembra,
los que permiten establecer conexiones entre el microcontrolador y los diferentes
sensores y actuadores de una manera muy sencilla (principalmente con cables dupont).
Una placa electrónica es una PCB (“Printed Circuit Board”, “Placa de Circuito Impreso” en
español). Las PCBs superficies planas fabricadas en un material no conductor, la cual costa
de distintas capas de material conductor. Una PCB es la forma más compacta y estable de
construir un circuito electrónico. Así que la placa Arduino no es más que una PCB que
implementa un determinado diseño de circuitería interna, de esta forma el usuario final no
se debe preocupar por las conexiones eléctricas que necesita el microcontrolador para
funcionar, y puede empezar directamente a desarrollar las diferentes aplicaciones
electrónicas que necesite.

PCB de un Arduino UNO

Cuando hablamos de “Arduino” deberíamos especificar el modelo concreto, ya que se han

fabricado diferentes modelos de placas Arduino oficiales, cada una pensada con un
propósito diferente y características variadas (como el tamaño físico, número de pines E/S,
modelo del microcontrolador, etc). A pesar de las varias placas que existen todas
pertenecen a la misma familia (microcontroladores AVR marca Atmel), esto significa que
comparten la mayoría de sus características de software, como arquitectura, librerías y
documentación.
¿Qué es un lector de huella?

El lector de huella digital es un sensor biométrico que es ideal para realizar un

sistema capaz de proteger lo que tú requieras por medio del análisis de tu huella
en Arduino. El sistema realiza procesamiento digital de imágenes de manera interna
con un DSP (Procesador de Señales Digitales) Además incluye capacidades de
comparación en base de datos y actualización de la misma. El dispositivo funciona
con el protocolo serial, por lo que puede ser utilizado con cualquier micro
controlador o tarjeta de desarrollo.

El dispositivo tiene la capacidad de almacenar hasta 162 huellas dactilares en su

memoria FLASH interna. El LED del dispositivo se ilumina cada que se encuentra
tomando imágenes en busca de huellas digitales.
 Modelo: 071405
 Voltaje de alimentación: 3.6V – 6V
 Corriente de operación: 100mA – 150mA
 Interfaz: UART TTL
 Modo de paridad de huella: 1:1 1:N
 Baud Rate: 9600*N
 N = 1 a 12 (Por defecto es 6)
 Tiempo de adquisición menor a 1 segundo
 5 Niveles de seguridad
 Dimensión de la ventana: 14x18mm
 Entorno de trabajo: -10ºC a 40ºC (Humedad Relativa 40% a 85%)
 Dimensiones: 5.5 x 2.1 x 2.0 cm
 Peso: 22g

Por lo tanto:
Para poder utilizar el dispositivo es necesario guardar las huellas en la base de datos
del mismo. Estas huellas se les asigna un ID. Posteriormente se puede iniciar la
secuencia de lectura y comparación para verificar las huellas de los usuarios y así
poder discernir y ejecutar acciones en base al resultado.
Para utilizar el código de ejemplo es necesario primero tomar en cuenta que los
cables del dispositivo no tienen acoplado ningún conector por lo que se recomienda
soldar pines macho o pines hembra, ya que los headers de arduino o de un
protoboard no hacen bien contacto y son motivo de que el dispositivo no funcione
correctamente.
 Lector de huella digital

IV. PROCEDIMIENTO
Para la elaboración necesitaremos de una librería para poder realizar el código en
ARDUINO.
La librería a utilizar es:

Ardafruit_fingerprint.h

La cual es la siguiente:

#ifndef ADAFRUIT_FINGERPRINT_H
#define ADAFRUIT_FINGERPRINT_H

#include "Arduino.h"
#if defined(__AVR__) || defined(ESP8266)
#include <SoftwareSerial.h>
#elif defined(FREEDOM_E300_HIFIVE1)
#include <SoftwareSerial32.h>
#define SoftwareSerial SoftwareSerial32
#endif

#define FINGERPRINT_OK 0x00

#define FINGERPRINT_PACKETRECIEVEERR
0x01
#define FINGERPRINT_NOFINGER 0x02
#define FINGERPRINT_IMAGEFAIL 0x03
#define FINGERPRINT_IMAGEMESS 0x06
#define FINGERPRINT_FEATUREFAIL 0x07
#define FINGERPRINT_NOMATCH 0x08
#define FINGERPRINT_NOTFOUND 0x09
#define FINGERPRINT_ENROLLMISMATCH 0x0A
#define FINGERPRINT_BADLOCATION 0x0B
#define FINGERPRINT_DBRANGEFAIL 0x0C
#define FINGERPRINT_UPLOADFEATUREFAIL
0x0D
#define FINGERPRINT_PACKETRESPONSEFAIL
0x0E
#define FINGERPRINT_UPLOADFAIL 0x0F
#define FINGERPRINT_DELETEFAIL 0x10
#define FINGERPRINT_DBCLEARFAIL 0x11
#define FINGERPRINT_PASSFAIL 0x13
#define FINGERPRINT_INVALIDIMAGE 0x15
#define FINGERPRINT_FLASHERR 0x18
#define FINGERPRINT_INVALIDREG 0x1A
#define FINGERPRINT_ADDRCODE 0x20
#define FINGERPRINT_PASSVERIFY 0x21

#define FINGERPRINT_STARTCODE 0xEF01

#define FINGERPRINT_COMMANDPACKET 0x1

#define FINGERPRINT_DATAPACKET 0x2
#define FINGERPRINT_ACKPACKET 0x7
#define FINGERPRINT_ENDDATAPACKET 0x8

#define FINGERPRINT_TIMEOUT 0xFF

#define FINGERPRINT_BADPACKET 0xFE

#define FINGERPRINT_GETIMAGE 0x01

#define FINGERPRINT_IMAGE2TZ 0x02
#define FINGERPRINT_REGMODEL 0x05
#define FINGERPRINT_STORE 0x06
#define FINGERPRINT_LOAD 0x07
#define FINGERPRINT_UPLOAD 0x08
#define FINGERPRINT_DELETE 0x0C
#define FINGERPRINT_EMPTY 0x0D
#define FINGERPRINT_SETPASSWORD 0x12
#define FINGERPRINT_VERIFYPASSWORD 0x13
#define FINGERPRINT_HISPEEDSEARCH 0x1B
#define FINGERPRINT_TEMPLATECOUNT 0x1D

//#define FINGERPRINT_DEBUG

#define DEFAULTTIMEOUT 1000 ///< UART reading

timeout in milliseconds
///! Helper class to craft UART packets
struct Adafruit_Fingerprint_Packet {

Adafruit_Fingerprint_Packet(uint8_t type, uint16_t

length, uint8_t * data) {
this->start_code = FINGERPRINT_STARTCODE;
this->type = type;
this->length = length;
address[0] = 0xFF; address[1] = 0xFF;
address[2] = 0xFF; address[3] = 0xFF;
if(length<64)
memcpy(this->data, data, length);
else
memcpy(this->data, data, 64);
}
uint16_t start_code; ///< "Wakeup" code for
packet detection
uint8_t address[4]; ///< 32-bit Fingerprint sensor
address
uint8_t type; ///< Type of packet
uint16_t length; ///< Length of packet
uint8_t data[64]; ///< The raw buffer for packet
payload
};

///! Helper class to communicate with and keep state

for fingerprint sensors
class Adafruit_Fingerprint {
public:
#if defined(__AVR__) || defined(ESP8266) ||
defined(FREEDOM_E300_HIFIVE1)
Adafruit_Fingerprint(SoftwareSerial *ss, uint32_t
password = 0x0);
#endif
Adafruit_Fingerprint(HardwareSerial *hs, uint32_t
password = 0x0);

void begin(uint32_t baud);

 boolean verifyPassword(void);
uint8_t getImage(void);
uint8_t image2Tz(uint8_t slot = 1);
uint8_t createModel(void);

uint8_t emptyDatabase(void);
uint8_t storeModel(uint16_t id);
uint8_t loadModel(uint16_t id);
uint8_t getModel(void);
uint8_t deleteModel(uint16_t id);
uint8_t fingerFastSearch(void);
uint8_t getTemplateCount(void);
uint8_t setPassword(uint32_t password);
void writeStructuredPacket(const
Adafruit_Fingerprint_Packet & p);
uint8_t
getStructuredPacket(Adafruit_Fingerprint_Packet * p,
uint16_t timeout=DEFAULTTIMEOUT);

/// The matching location that is set by

fingerFastSearch()
uint16_t fingerID;
/// The confidence of the fingerFastSearch() match,
higher numbers are more confidents
uint16_t confidence;
/// The number of stored templates in the sensor, set
by getTemplateCount()
uint16_t templateCount;

private:
uint8_t checkPassword(void);
uint32_t thePassword;
uint32_t theAddress;
uint8_t recvPacket[20];

Stream *mySerial;
 #if defined(__AVR__) || defined(ESP8266) ||
defined(FREEDOM_E300_HIFIVE1)
SoftwareSerial *swSerial;
#endif
HardwareSerial *hwSerial;
};

#endif

Una vez tengamos la librería procedemos a realizar el código declarando la librería ya

mencionada anteriormente, se utilizaran principalmente dos códigos los cuales son para
registrar y el otro para la lectura de la huella.

Los cuales definiremos a continuación:

Para el registro de las huellas:

#include <Adafruit_Fingerprint.h>

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

uint8_t id;

void setup()
{

Serial.begin(9600);

while (!Serial);

delay(100);

Serial.println("\n\nAdafruit Fingerprint sensor enrollment");

finger.begin(57600);

if (finger.verifyPassword()) {

Serial.println("Sensor encontrado!");

//Se mostrara este mensaje si el software reconoce el dispositivo en este caso el lector
de huella

} else {

Serial.println("Sensor NO encontrado");

//Se mostrara este mensaje si el software NO reconoce el dispositivo en este caso el

lector de huella

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() //la acción se repetirá

Serial.println("Listo para registrar huella");

Serial.println("Asignar un número a la huella entre 1 y 127");

id = readnumber();

if (id == 0) {// ID #0 not allowed, try again!

return;

Serial.print("Registrando huella");

Serial.println(id);

while (! getFingerprintEnroll() );

uint8_t getFingerprintEnroll() {

int p = -1;

Serial.print("Esperando lectura valida"); Serial.println(id);

while (p != FINGERPRINT_OK) {

p = finger.getImage();

switch (p) {

case FINGERPRINT_OK:

Serial.println("Imagen tomada");

break;
 case FINGERPRINT_NOFINGER:

Serial.println(".");

break;

case FINGERPRINT_PACKETRECIEVEERR:

Serial.println("Error");

break;

case FINGERPRINT_IMAGEFAIL:

Serial.println("Error de imagen");

break;

default:

Serial.println("Error desconocido");

break;

p = finger.image2Tz(1);

switch (p) {

case FINGERPRINT_OK:

Serial.println("Imagen convertida");

break;

case FINGERPRINT_IMAGEMESS:

Serial.println("Imagen no clara");

return p;
 case FINGERPRINT_PACKETRECIEVEERR:

Serial.println("Error");

return p;

case FINGERPRINT_FEATUREFAIL:

Serial.println("No se encontraron las características de la huella");

return p;

case FINGERPRINT_INVALIDIMAGE:

Serial.println("No se pudo encontrar las características de la huella");

return p;

default:

Serial.println("Error desconocido");

return p;

Serial.println("Retire el dedo");

delay(2000);

p = 0;

while (p != FINGERPRINT_NOFINGER) {

p = finger.getImage();

Serial.print("ID "); Serial.println(id);

p = -1;

Serial.println("Coloque el mismo dedo, nuevamente");

while (p != FINGERPRINT_OK) {
 p = finger.getImage();

switch (p) {

case FINGERPRINT_OK:

Serial.println("Image tomada");

break;

case FINGERPRINT_NOFINGER:

Serial.print(".");

break;

case FINGERPRINT_PACKETRECIEVEERR:

Serial.println("Error");

break;

case FINGERPRINT_IMAGEFAIL:

Serial.println("Error de imagen");

break;

default:

Serial.println("Error desconocido");

break;

p = finger.image2Tz(2);

switch (p) {

case FINGERPRINT_OK:

Serial.println("Image convertida");
 break;

case FINGERPRINT_IMAGEMESS:

Serial.println("Imagen no clara");

return p;

case FINGERPRINT_PACKETRECIEVEERR:

Serial.println("Error");

return p;

case FINGERPRINT_FEATUREFAIL:

Serial.println("No se pudo encontrar las características de la huella");

return p;

case FINGERPRINT_INVALIDIMAGE:

Serial.println("No se pudo encontrar las características de la huella ");

return p;

default:

Serial.println("Error desconocido");

return p;

Serial.print("Creando para el numero de huella :"); Serial.println(id);

p = finger.createModel();

if (p == FINGERPRINT_OK) {

Serial.println("Las huellas coinciden");

} else if (p == FINGERPRINT_PACKETRECIEVEERR) {

Serial.println("error");
 return p;

} else if (p == FINGERPRINT_ENROLLMISMATCH) {

Serial.println("Las huellas NO coinciden");

return p;

} else {

Serial.println("Error desconocido");

return p;

Serial.print("ID "); Serial.println(id);

p = finger.storeModel(id);

if (p == FINGERPRINT_OK) {

Serial.println("Almacenado");

} else if (p == FINGERPRINT_PACKETRECIEVEERR) {

Serial.println("Error");

return p;

} else if (p == FINGERPRINT_BADLOCATION) {

Serial.println("No puede ser almacenada");

return p;

} else if (p == FINGERPRINT_FLASHERR) {

Serial.println("Error al escribir en la memoria flash");

return p;

} else {

Serial.println("error desconocido");
 return p;

Para la lectura de huella:

#include <Adafruit_Fingerprint.h>

#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

void setup()

pinMode(4,OUTPUT);
 pinMode(5,OUTPUT);

Serial.begin(9600);

while (!Serial); // For Yun/Leo/Micro/Zero/...

delay(100);

Serial.println("Prueba de sensor de huella");

// set the data rate for the sensor serial port

finger.begin(57600);

if (finger.verifyPassword()) {

Serial.println("Sensor encontrado");

} else {

Serial.println("Sensor no encontrado");

while (1) { delay(1); }

finger.getTemplateCount();

Serial.print("Sensor contiene "); Serial.print(finger.templateCount); Serial.println(" huellas

registradas");

Serial.println("Esperando huella valida ...");

void loop() // run over and over again

getFingerprintIDez();
 delay(50); //don't ned to run this at full speed.

digitalWrite(5,HIGH);

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("se encontro el ID numero : "); Serial.print(finger.fingerID);

Serial.print("con una fiabilidad de : "); 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!

digitalWrite(5,LOW);

digitalWrite(4,HIGH);

delay(1000);

digitalWrite(4,LOW);

Serial.print("se encontro el ID numero :"); Serial.print(finger.fingerID);

Serial.print(" con una fiabilidad de : "); Serial.println(finger.confidence);

return finger.fingerID;

}
Detector de huella

Cuando la huella insertada, no se

encuentra registrada

Cuando la huella insertada, est’a

registrada