Como construir uma máquina de votação biométrica baseada em Arduino

June 29, 2024 Roberto Magalhães

As máquinas de votação eletrônicas típicas exigem que os eleitores apertem um botão para votar. No entanto, houve preocupações de segurança com esses dispositivos e se eles correm risco de adulteração. Uma solução é usar máquinas de votação baseadas em biometria, que usam correspondência de impressão digital ou uma varredura de retina para verificar um eleitor autorizado.

Neste projeto, desenvolveremos uma máquina de votação biométrica com base na impressão digital de uma pessoa. Construiremos o dispositivo usando Arduino Mega, com uma tela sensível ao toque TFT de 3,5 polegadas e módulo de impressão digital R307. A tela sensível ao toque será a interface do usuário para o “eleitor” votar.

Componentes necessários

Arduino Mega x1
Tela sensível ao toque TFT de 3,5 polegadas para Arduino x1
Sensor de impressão digital R307 x1

Conexões de circuito
Para construir uma máquina de votação biométrica, precisamos primeiro conectar a tela sensível ao toque TFT de 3,5 polegadas e o sensor de impressão digital R307 com o Arduino Mega. A tela sensível ao toque é um shield Arduino que se encaixa sobre a placa.

Para fazer interface com o sensor de impressão digital:

Conecte os pinos VCC e GND do sensor R307 com os pinos 5Vout e terra do Arduino.
Conecte os pinos TX e RX do sensor R307 com RX1 e TX1 do Arduino.

As conexões do circuito são mostradas no diagrama abaixo.

Carregando as impressões digitais
Após fazer as conexões do circuito, precisamos “cadastrar” as impressões digitais dos eleitores válidos. Carregue o seguinte sketch no Arduino MEAG e uma única impressão digital de cada eleitor.

Para saber mais sobre a interface do sensor R307 e como registrar e corresponder impressões digitais nele, confira este projeto.

Preparando a urna eletrônica
Depois de cadastradas as impressões digitais dos eleitores autorizados, é hora de preparar a urna eletrônica para receber as cédulas. Usaremos a tela sensível ao toque TFT de 3,5 polegadas como interface do usuário.

Para calibrar a tela sensível ao toque:

Instale as bibliotecas Adafruit_GFX.h e MCUFRIEND_kbv.h no Arduino IDE
Navegue até Arquivo-> Exemplos -> MCUFRIEND_kbv -> Touchscreen_Calibr_native

Carregue o esboço de exemplo no Arduino Mega.
Abra o Serial Monitor do Arduino IDE e toque nos pontos de canto da tela sensível ao toque, conforme indicado pelos sinais +, usando uma caneta.

Você deve anotar os valores para XP, XM, YP, YM, TS_LEFT,TS_RT, TS_TOP e TS_BOT. É importante copiar esses valores do Serial Monitor e salvá-los em um arquivo de texto para uso posterior.

Para nossa tela sensível ao toque, as variáveis apresentaram os seguintes valores:

const int XP=6,XM=A2,YP=A1,YM=7; //320×480 ID=0x9486
const int TS_ESQUERDA=931,TS_RT=168,TS_TOP=452,TS_BOT=191;

Em seguida, carregue o seguinte esboço no Arduino Mega, para que ele funcione como uma máquina de votação biométrica.

Como funciona
O primeiro esboço carregado configura um “admin” no Serial Monitor do Arduino IDE para registrar as impressões digitais dos eleitores autorizados. O sensor de impressão digital R307 permite até 128 impressões digitais indexadas de 0 a 127.

A máquina deve ser preparada para a votação em seguida, calibrando a tela sensível ao toque usando o esboço de exemplo. Após o upload do esboço final, o Arduino reinicia. Ele então exibe a interface do usuário onde os eleitores podem selecionar um dos três candidatos.

Quando um eleitor pressiona o botão na tela sensível ao toque ao lado de seu candidato preferido, outra tela aparece no display TFT, solicitando uma leitura de impressão digital. O eleitor deve colocar o dedo indicador no sensor de impressão digital. O sensor piscará um LED, capturando uma imagem de sua impressão digital.

Se a impressão digital coincidir com a impressão cadastrada, o voto é contabilizado e uma tela de agradecimento ao eleitor aparece no display TFT. Caso o eleitor não esteja inscrito, será exibida a mensagem “Desculpe, você não pode votar”. aparecerá no display TFT.

Depois, a tela principal reaparece, permitindo que outros votem.

O código
O esboço principal começa importando as bibliotecas Adafruit_GFX.h, MCUFRIEND_kbv.h, TouchScreen.h e EEPROM.h. O Adafruit_GFX.h e MCUFRIEND_kbv.h são necessários para operar o display TFT de 3,5 polegadas. O TouchScreen.h é necessário para que a tela sensível ao toque funcione como um dispositivo de votação. A biblioteca EEPROM.h é usada para armazenar os votos na memória EEPROM do Arduino.

As linhas de código a seguir definem a porta serial para comunicação com o sensor R307, instanciando um objeto para a correspondência adequada de impressão digital.

#incluir
#if (definido(__AVR__) definido(ESP8266)) && !definido(__AVR_ATmega2560__)
SoftwareSerial mySerial(2, 3);
#outro
#define meuSerial Serial1
#fim se
Adafruit_Fingerprint dedo = Adafruit_Fingerprint(&mySerial);

Segue-se a definição de variáveis, que armazenam o número total de votos dos três candidatos. As linhas de código a seguir definem as constantes de cores para a tela TFT e instanciam um objeto de exibição.

#define PRETO 0x0000
#define AZUL 0x001F
#define VERMELHO 0xF800
#define VERDE 0x07E0
#define CIANO 0x07FF
#define MAGENTA 0xF81F
#define AMARELO 0xFFE0
#define BRANCO 0xFFFF
MCUFRIEND_kbvtft

Em seguida, as constantes são definidas para a função da tela sensível ao toque e a instanciação de um objeto de toque.

#define MINPRESSÃO 10
#define PRESSÃO MÁXIMA 1000
const int XP=6,XM=A2,YP=A1,YM=7; //320×480 ID=0x9486
const int TS_LEFT=931,TS_RT=168,TS_TOP=452,TS_BOT=191;
#define TS_MINX 125
#define TS_MINY 85
#defineTS_MAXX965
#define TS_MAXY 905
Tela sensível ao toque (XP, YP, XM, YM, 300); //reinicializado após diagnóstico
TSPoint tp; //ponto global

Na função setup , a tela TFT é inicializada usando o seguinte código.

tft.reset ;
tft.begin(tft.readID );
tft.setRotation(2);

O sensor de impressão digital é inicializado usando as seguintes linhas de código na função setup .

Serial.begin(9600);
Serial.println ;
Serial.print(“lendo id…”);
atraso(500);
Serial.println(tft.readID , HEX);
dedo.begin(57600);
atraso(5);
se (dedo.verificarSenha ) {
Serial.println(“Sensor de impressão digital encontrado!”);
}
outro {
Serial.println(“Não foi encontrado sensor de impressão digital :(“);
enquanto (1) { atraso (1); }
}

Por fim, a interface do usuário do eleitor para votação é exibida na tela TFT, usando o seguinte.

tft.fillScreen(PRETO);
Lar ;
pinMode(13, SAÍDA);
resultado ;

A função Home define e exibe a tela principal da urna eletrônica, onde o eleitor pode votar em um dos três candidatos.

casa vazia
{
tft.fillScreen(PRETO);
tft.drawRoundRect(0, 0, 320, 480, 8, BRANCO); //Borda da página
tft.setCursor(105, 5);
tft.setTextSize(3);
tft.setTextColor(CYAN);
tft.print(“Votação”);
tft.setCursor(97, 29);
tft.print(“Máquina”);

tft.drawRoundRect(35, 70, 250, 50, 8, BRANCO); //Votar
tft.fillRoundRect(35, 70, 250, 50, 8, AMARELO);
tft.setTextSize(3);
tft.setTextColor(BRANCO);
tft.setCursor(60, 82);
tft.print(“Candidato 1”);

tft.drawRoundRect(35, 160, 250, 50, 8, BRANCO); //Inscrever-se
tft.fillRoundRect(35, 160, 250, 50, 8, AMARELO);
tft.setCursor(60, 172);
tft.print(“Candidato 2”);

tft.drawRoundRect(35, 250, 250, 50, 8, BRANCO);
tft.fillRoundRect(35, 250, 250, 50, 8, AMARELO); //Resultado
tft.setCursor(60, 262);
tft.print(“Candidato 3”);
}

A interface do usuário é definida de acordo com a resolução da tela sensível ao toque TFT de 3,5 polegadas, que é de 480×320 pixels.

Screen1 define a tela da interface do usuário, solicitando que o eleitor escaneie o dedo indicador para autenticação.

tela vazia1
{
tft.fillScreen(PRETO);
tft.setTextSize(3);
tft.setTextColor(BRANCO);
tft.setCursor(70, 190);
tft.print(“Por favor, digitalize”);
tft.setCursor(70, 240);
tft.print(“Seu Dedo”);
Serial.println(“Por favor, pressione o dedo”);
}

Screen2 define a interface do usuário, que aparece quando o usuário não é validado como eleitor inscrito.

tela vazia2
{
Serial.println(“Dedo não encontrado”);
tft.fillScreen(PRETO);
tft.setTextSize(3);
tft.setCursor(70, 190);
tft.print(“Desculpe”);
tft.setCursor(70, 240);
tft.print(“Não posso votar”);
atraso(3000);
Lar ;
}

A função fingerprintMatch verifica e corresponde as impressões digitais de plantão e retorna TRUE se a impressão digital for correspondente e FALSE se não for.

bool impressão digitalMatch {
tela1 ;
atraso(5000);
uint8_t p = dedo.getImage ;
if (p == FINGERPRINT_NOFINGER) vai para NoFinger;
senão se (p == IMPRESSÃO_DEDAL_OK) {
p = dedo.image2Tz ;
se (p != IMPRESSÃO_DEDAL_OK) vá para NoMatch;
p = dedo.fingerFastSearch ;
se (p != IMPRESSÃO_DEDAL_OK) vá para NoMatch;
Serial.print(“ID verificado:”);
Serial.println(dedo.IDdo);
atraso(1500);
retornar verdadeiro;
}
Sem correspondência:
{
retorna falso;
}
Sem dedo:
{
Serial.println(“Nenhum dedo detectado”);
atraso(1500);
retorna falso;
}
}

Na função loop , um sinal HIGH-to-LOW é enviado no pino GPIO13 em interface com a tela sensível ao toque para iniciar a detecção de toque. Um objeto para a função touch é inicializado. Caso a pressão exercida pelo eleitor na tela sensível ao toque esteja acima de um limite específico, as posições dos pixels são mapeadas.

Durante a fase de teste, essas posições de pixels são impressas no console serial para determinar os pontos exatos de toque dos botões (na interface do usuário) dos três candidatos. Posteriormente, essas linhas de código serão comentadas.

digitalWrite(13, ALTO);
digitalWrite(13, BAIXO);
TSPoint p = ts.getPoint ;
// se estiver compartilhando pins, você precisará corrigir as direções dos pins da tela sensível ao toque
//pinMode(XP, SAÍDA);
//pinMode(YM, SAÍDA);
pinMode(XM, SAÍDA);
pinMode(YP, SAÍDA);

se (pz > ts.pressureThreshhold)
{
px = mapa(px, TS_MAXX, TS_MINX, 0, 320);
py = mapa(py, TS_MAXY, TS_MINY, 0, 240);
//Serial.print(“X:”); // Usei isso para obter os pontos de toque precisos para os eixos X e Y
//Serial.print(px);
//Serial.print(” “);
//Serial.print(“Y:”);
//Serial.println(py);

Se os pontos de contato corresponderem a 'candidato1', a impressão digital do eleitor será verificada para concluir o processo de votação. A exibição retorna à janela de votação se o voto for aceito (e válido) ou rejeitado.

se (px > 50 && px < 280 && py > 160 && py < 190 && pz > PRESSÃO MÍNIMA && pz < PRESSÃO MÁXIMA)
{
Serial.println(“Candidato 1”);
se(impressãodigitalCorresponder )
{
votar1++;
EEPROM.write(0, voto1);
tft.fillScreen(PRETO);
tft.setCursor(70, 220);
tft.print(“Obrigado”);
atraso(3000);
Lar ;
}
outro
{
tela2 ;
}
}

O mesmo é feito para outros dois candidatos. Os resultados da votação são impressos no console serial em uma reinicialização, pois os resultados são salvos na EEPROM. Os resultados são calculados pela função results .

resultado nulo
{
voto1=EEPROM.read(0);
voto2=EEPROM.read(1);
vote3=EEPROM.read(2);
int voto=voto1+voto2+voto3;
Serial.println(voto1);
Serial.println(voto2);
Serial.println(voto3);
se(votar)
{
se((voto1 > voto2 && voto1 > voto3))
{
Serial.print(“Candidato 1 vence”);
atraso(2000);
}
senão if(voto2 > voto1 && voto2 > voto3)
{
Serial.print(“Candidato 2 vence”);
atraso(2000);
}
senão se((voto3 > voto1 && voto3 > voto2))
{
Serial.print(“Candidato 3 vence”);
atraso(2000);
}
outro
{
Serial.print(“Amarrar Ou”);
Serial.print(“Nenhum resultado”);
atraso(1000);
}
}
outro
{
Serial.print(“Sem votação….”);
atraso(1000);
}
}