Las máquinas de votación electrónicas típicas requieren que los votantes presionen un botón para votar. Sin embargo, ha habido preocupaciones de seguridad sobre estos dispositivos y si corren riesgo de ser manipulados. Una solución es utilizar máquinas de votación basadas en biometría, que utilizan la comparación de huellas dactilares o un escaneo de retina para verificar a un votante autorizado.
En este proyecto desarrollaremos una máquina de votación biométrica basada en la huella digital de una persona. Construiremos el dispositivo utilizando Arduino Mega, con una pantalla táctil TFT de 3,5 pulgadas y un módulo de huellas dactilares R307. La pantalla táctil será la interfaz de usuario para que el “votante” vote.
Componentes necesarios
- ArduinoMegax1
- Pantalla táctil TFT de 3,5 pulgadas para Arduino x1
- Sensor de huellas dactilares R307 x1
Conexiones de circuito
Para construir una máquina de votación biométrica, primero necesitamos conectar la pantalla táctil TFT de 3,5 pulgadas y el sensor de huellas dactilares R307 con Arduino Mega. La pantalla táctil es un escudo Arduino que encaja en la placa.
Para interactuar con el sensor de huellas dactilares:
- Conecte los pines VCC y GND del sensor R307 con los pines 5Vout y tierra del Arduino.
- Conecta los pines TX y RX del sensor R307 con RX1 y TX1 del Arduino.
Las conexiones del circuito se muestran en el siguiente diagrama.
Cargando huellas dactilares
Después de realizar las conexiones del circuito, necesitamos “registrar” las huellas dactilares de los votantes válidos. Cargue el siguiente boceto en el Arduino MEAG y una única huella digital de cada votante.
Para obtener más información sobre la interfaz del sensor R307 y cómo registrar y comparar huellas dactilares en ella, consulte este proyecto.
Preparando la urna electrónica
Una vez registradas las huellas dactilares de los electores autorizados, llega el momento de preparar la urna electrónica para recibir las papeletas. Usaremos la pantalla táctil TFT de 3,5 pulgadas como interfaz de usuario.
Para calibrar la pantalla táctil:
- Instale las bibliotecas Adafruit_GFX.h y MCUFRIEND_kbv.h en el IDE de Arduino
- Vaya a Archivo-> Ejemplos -> MCUFRIEND_kbv -> Touchscreen_Calibr_native
- Cargue el boceto de ejemplo en el Arduino Mega.
- Abra el monitor serie del IDE de Arduino y toque las esquinas de la pantalla táctil, como lo indican los signos +, usando un lápiz.
Debes anotar los valores de XP, XM, YP, YM, TS_LEFT,TS_RT, TS_TOP y TS_BOT. Es importante copiar estos valores de Serial Monitor y guardarlos en un archivo de texto para su uso posterior.
Para nuestra pantalla táctil, las variables tenían los siguientes valores:
- constante int XP=6,XM=A2,YP=A1,YM=7; //320×480 ID=0x9486
- constante int TS_LEFT=931,TS_RT=168,TS_TOP=452,TS_BOT=191;
Luego sube el siguiente boceto al Arduino Mega, para que funcione como una máquina de votación biométrica.
Como funciona
El primer boceto cargado configura un "administrador" en el monitor serie del IDE de Arduino para registrar las huellas dactilares de los votantes autorizados. El sensor de huellas dactilares R307 permite hasta 128 huellas dactilares indexadas de 0 a 127.
La máquina debe estar preparada para la próxima votación calibrando la pantalla táctil usando el boceto de ejemplo. Una vez cargado el boceto final, Arduino se reinicia. Luego muestra la interfaz de usuario donde los votantes pueden seleccionar uno de tres candidatos.
Cuando un votante presiona el botón en la pantalla táctil junto a su candidato preferido, aparece otra pantalla en la pantalla TFT, lo que solicita un escaneo de huellas dactilares. El elector deberá colocar su dedo índice sobre el sensor de huellas dactilares. El sensor hará parpadear un LED, capturando una imagen de su huella digital.
Si la huella digital coincide con la huella registrada, se cuenta el voto y aparece una pantalla de agradecimiento al votante en la pantalla TFT. Si el elector no está registrado, se mostrará el mensaje “Lo sentimos, no puedes votar”. aparecerá en la pantalla TFT.
Luego reaparece la pantalla principal, permitiendo que otros voten.
Código
El esquema principal comienza importando las bibliotecas Adafruit_GFX.h, MCUFRIEND_kbv.h, TouchScreen.h y EEPROM.h. Se requieren Adafruit_GFX.h y MCUFRIEND_kbv.h para operar la pantalla TFT de 3,5 pulgadas. Se requiere TouchScreen.h para que la pantalla táctil funcione como dispositivo de votación. La biblioteca EEPROM.h se utiliza para almacenar votos en la memoria EEPROM del Arduino.
Las siguientes líneas de código definen el puerto serie para comunicarse con el sensor R307, creando una instancia de un objeto para una coincidencia adecuada de huellas dactilares.
#incluir
#if (definido(__AVR__) definido(ESP8266)) && !definido(__AVR_ATmega2560__)
SoftwareSerial mySerial(2, 3);
#otro
#definir miSerial Serial1
#terminara si
Adafruit_Fingerprint dedo = Adafruit_Fingerprint(&mySerial);
A esto le sigue la definición de variables, que almacenan el número total de votos de los tres candidatos. Las siguientes líneas de código definen las constantes de color para la pantalla TFT y crean una instancia de un objeto de visualización.
#definir NEGRO 0x0000
#definir AZUL 0x001F
#definir ROJO 0xF800
#definir VERDE 0x07E0
#definir CIAN 0x07FF
#definir MAGENTA 0xF81F
#definir AMARILLO 0xFFE0
#definir BLANCO 0xFFFF
MCUFRIEND_kbvtft
A continuación, se definen constantes para la función de la pantalla táctil y la creación de instancias de un objeto táctil.
#definir PRESIÓN MIN 10
#define PRESIÓN MÁXIMA 1000
constante int XP=6,XM=A2,YP=A1,YM=7; //320×480 ID=0x9486
constante int TS_LEFT=931,TS_RT=168,TS_TOP=452,TS_BOT=191;
#definir TS_MINX 125
#definir TS_MINY 85
#definirTS_MAXX965
#definir TS_MAXY 905
Pantalla táctil (XP, YP, XM, YM, 300); //restablecer después del diagnóstico
TSPoint tp; //punto global
En la función de configuración, la pantalla TFT se inicializa usando el siguiente código.
tft.restablecer;
tft.begin(tft.readID);
tft.setRotation(2);
El sensor de huellas dactilares se inicializa utilizando las siguientes líneas de código en la función de configuración.
Serie.begin(9600);
Serial.println;
Serial.print(“identificación de lectura…”);
retraso(500);
Serial.println(tft.readID, HEX);
dedo.comenzar(57600);
retraso(5);
if (dedo.verificarContraseña) {
Serial.println(“¡Sensor de huellas dactilares encontrado!”);
}
otro {
Serial.println(“No se encontró ningún sensor de huellas digitales :(“);
mientras (1) { demora (1); }
}
Finalmente, la interfaz de usuario del votante para votar se muestra en la pantalla TFT usando lo siguiente.
tft.fillScreen(NEGRO);
Hogar;
pinMode(13, SALIDA);
resultado;
La función Inicio define y muestra la pantalla principal de la urna electrónica, donde el elector puede votar por uno de los tres candidatos.
casa vacía
{
tft.fillScreen(NEGRO);
tft.drawRoundRect(0, 0, 320, 480, 8, BLANCO); //borde de página
tft.setCursor(105, 5);
tft.setTextSize(3);
tft.setTextColor(CYAN);
tft.print(“Votar”);
tft.setCursor(97, 29);
tft.print(“Máquina”);
tft.drawRoundRect(35, 70, 250, 50, 8, BLANCO); //Votar
tft.fillRoundRect(35, 70, 250, 50, 8, AMARILLO);
tft.setTextSize(3);
tft.setTextColor(BLANCO);
tft.setCursor(60, 82);
tft.print(“Candidato 1”);
tft.drawRoundRect(35, 160, 250, 50, 8, BLANCO); //Inscribirse
tft.fillRoundRect(35, 160, 250, 50, 8, AMARILLO);
tft.setCursor(60, 172);
tft.print(“Candidato 2”);
tft.drawRoundRect(35, 250, 250, 50, 8, BLANCO);
tft.fillRoundRect(35, 250, 250, 50, 8, AMARILLO); //Resultado
tft.setCursor(60, 262);
tft.print(“Candidato 3”);
}
La interfaz de usuario se configura según la resolución de la pantalla táctil TFT de 3,5 pulgadas, que es de 480×320 píxeles.
Screen1 configura la pantalla de la interfaz de usuario, solicitando al votante que escanee su dedo índice para autenticarse.
pantalla vacía1
{
tft.fillScreen(NEGRO);
tft.setTextSize(3);
tft.setTextColor(BLANCO);
tft.setCursor(70, 190);
tft.print(“Escanee”);
tft.setCursor(70, 240);
tft.print(“Tu dedo”);
Serial.println(“Presione el dedo”);
}
La pantalla 2 define la interfaz de usuario, que aparece cuando el usuario no está validado como votante registrado.
pantalla vacía2
{
Serial.println(“Dedo no encontrado”);
tft.fillScreen(NEGRO);
tft.setTextSize(3);
tft.setCursor(70, 190);
tft.print(“Lo siento”);
tft.setCursor(70, 240);
tft.print(“No puedo votar”);
retraso(3000);
Hogar;
}
La función huellas dactilaresMatch verifica y coincide con las huellas digitales de guardia y devuelve VERDADERO si la huella digital coincide y FALSO si no es así.
bool huella digital Match {
pantalla1;
retraso(5000);
uint8_t p = dedo.getImage;
si (p == FINGERPRINT_NOFINGER) va a NoFinger;
en caso contrario if (p == IMPRESSÃO_DEDAL_OK) {
p = dedo.imagen2Tz;
si (p != IMPRESSÃO_DEDAL_OK) vaya a NoMatch;
p = dedo.fingerFastSearch;
si (p != IMPRESSÃO_DEDAL_OK) vaya a NoMatch;
Serial.print(“ID verificada:”);
Serial.println(dedo.IDdo);
retraso(1500);
devolver verdadero;
}
Sin coincidencia:
{
devuelve falso;
}
Sin dedos:
{
Serial.println(“No se detectaron dedos”);
retraso(1500);
devuelve falso;
}
}
En la función de bucle, se envía una señal de ALTO a BAJO en el pin GPIO13 conectado a la pantalla táctil para iniciar la detección táctil. Se inicializa un objeto para la función táctil. Si la presión ejercida por el elector sobre la pantalla táctil supera un umbral específico, se mapean las posiciones de los píxeles.
Durante la fase de prueba, estas posiciones de píxeles se imprimen en la consola serie para determinar los puntos exactos de contacto de los botones (en la interfaz de usuario) de los tres candidatos. Más adelante, estas líneas de código se comentarán.
escritura digital (13, ALTA);
escritura digital(13, ABAJO);
TSPoint p = ts.getPoint;
// si estás compartiendo pines, necesitarás corregir las direcciones de los pines en la pantalla táctil
//pinMode(XP, SALIDA);
//pinMode(YM, SALIDA);
pinMode(XM, SALIDA);
pinMode(YP, SALIDA);
si (pz > ts.presiónUmbral)
{
px = mapa(px, TS_MAXX, TS_MINX, 0, 320);
py = mapa(py, TS_MAXY, TS_MINY, 0, 240);
//Serial.print(“X:”); // Usé esto para obtener los puntos de contacto precisos para los ejes X e Y
//Serial.print(px);
//Serial.print(” “);
//Serial.print(“Y:”);
//Serial.println(py);
Si los puntos de contacto coinciden con 'candidato1', se verificará la huella digital del votante para completar el proceso de votación. La pantalla vuelve a la ventana de votación si el voto es aceptado (y válido) o rechazado.
if (px > 50 && px < 280 && py > 160 && py < 190 && pz > PRESIÓN MÍNIMA && pz < PRESIÓN MÁXIMA)
{
Serial.println(“Candidato 1”);
si (coincidencia de huellas dactilares)
{
votar1++;
EEPROM.write(0, voto1);
tft.fillScreen(NEGRO);
tft.setCursor(70, 220);
tft.print(“Gracias”);
retraso(3000);
Hogar;
}
otro
{
pantalla2;
}
}
Lo mismo se hace con otros dos candidatos. Los resultados de la votación se imprimen en la consola serie al reiniciar mientras los resultados se guardan en EEPROM. Los resultados se calculan mediante la función de resultados.
resultado nulo
{
voto1=EEPROM.read(0);
voto2=EEPROM.read(1);
voto3=EEPROM.read(2);
int voto=voto1+voto2+voto3;
Serial.println(voto1);
Serial.println(voto2);
Serial.println(voto3);
si (votar)
{
if((voto1 > voto2 && voto1 > voto3))
{
Serial.print(“El candidato 1 gana”);
retraso(2000);
}
else if(voto2 > voto1 && voto2 > voto3)
{
Serial.print(“El candidato 2 gana”);
retraso(2000);
}
else if((voto3 > voto1 && voto3 > voto2))
{
Serial.print(“El candidato 3 gana”);
retraso(2000);
}
otro
{
Serial.print(“Empatar O”);
Serial.print(“Sin resultados”);
retraso(1000);
}
}
otro
{
Serial.print(“Sin voto…”);
retraso(1000);
}
}
Resultados
Vídeo de demostración:
A continuación se muestra una captura de pantalla del proceso de votación en la consola serie para la demostración anterior.
