Arduino UNO Based Biometric Electronic Voting System with LCD Display and Fingerprint Authentication

The Arduino UNO Based Biometric Electronic Voting System is a secure and intelligent digital polling solution that integrates fingerprint authentication, push-button voting, real-time LCD display, and buzzer feedback. This advanced embedded systems project enhances traditional electronic voting machines by incorporating biometric verification to prevent duplicate or unauthorized voting.

At the core of the system is the Arduino UNO microcontroller, which manages voter authentication, vote counting, and result display. A fingerprint sensor module is used to verify voter identity before allowing access to the voting buttons. Once authenticated, the voter can select their preferred candidate using dedicated push buttons connected via breadboards.

The system features a 16x2 LCD display that provides clear on-screen instructions, voter verification status, candidate names, and real-time vote counts. A buzzer is integrated to give audible confirmation after successful fingerprint verification and vote submission, improving user interaction and system reliability.

Key Functional Workflow:

System initializes and displays a welcome message on the LCD.
Voter places their finger on the fingerprint sensor for identity verification.
If authentication is successful, the LCD prompts the voter to select a candidate.
The voter presses the corresponding push button.
Arduino increments the vote count and displays confirmation.
Buzzer sounds to confirm successful vote registration.
The system prevents duplicate voting by tracking authenticated fingerprints.

Technical Highlights:

Biometric authentication using fingerprint sensor module
Real-time vote counting using Arduino UNO
16x2 LCD interface for user guidance and results display
Push-button based candidate selection
Buzzer feedback system for confirmation alerts
Digital input handling with debouncing
Secure voting logic to prevent multiple votes
Breadboard-based hardware prototyping

Code:

#include <Adafruit_Fingerprint.h>
#include <LiquidCrystal_I2C.h>  // Include the I2C library for the LCD
#include <SoftwareSerial.h>
#include <Servo.h>
#include <EEPROM.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);  // LCD with I2C address
SoftwareSerial fingerPrint(2, 3);    // RX and TX pins for fingerprint sensor
Servo myServo;

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&fingerPrint);

// Button and pin definitions
#define enroll A1
#define del A0
#define up A2
#define down A3
#define startButton 6         // Button to start fingerprint scan
#define resultbutton A4
#define candidate1 4
#define candidate2 A5
#define candidate3 A6
#define servoPin 5
#define buzzer 8

uint8_t id;
int voteCount1, voteCount2, voteCount3;

void setup() 
{
    delay(1000);
    myServo.attach(servoPin);
    myServo.write(180);  // Close the servo initially

    // Set pin modes
    pinMode(enroll, INPUT_PULLUP);
    pinMode(up, INPUT_PULLUP); 
    pinMode(down, INPUT_PULLUP); 
    pinMode(del, INPUT_PULLUP); 
    pinMode(buzzer, OUTPUT);
    pinMode(candidate1, INPUT_PULLUP);
    pinMode(candidate2, INPUT_PULLUP);
    pinMode(candidate3, INPUT_PULLUP);
    pinMode(resultbutton, INPUT_PULLUP);
    pinMode(startButton, INPUT_PULLUP);

    // Initialize the LCD with the correct parameters
    lcd.begin(16, 2);
    lcd.print("Voting system");
    lcd.setCursor(0, 1);
    lcd.print("by Finger Print");
    delay(2000);
    lcd.clear();

    finger.begin(57600);
    Serial.begin(9600);

    lcd.print("Finding Module");
    delay(1000);
    if (finger.verifyPassword()) 
    {
        Serial.println("Found fingerprint sensor!");
        lcd.clear();
        lcd.print("Module Found");
        delay(1000);
    } 
    else 
    {
        Serial.println("Fingerprint sensor not found.");
        lcd.clear();
        lcd.print("Module Not Found");
        lcd.setCursor(0, 1);
        lcd.print("Check Connections");
        while (1);
    }

    // Load stored vote counts from EEPROM
    voteCount1 = EEPROM.read(0);
    voteCount2 = EEPROM.read(1);
    voteCount3 = EEPROM.read(2);
}

void loop() 
{
    lcd.setCursor(0, 0);
    lcd.print("Press Start ");
    lcd.setCursor(0, 1);
    lcd.print("to begin voting");

    if (digitalRead(startButton) == LOW)
    {
        lcd.clear();
        lcd.print("Place Finger");
        delay(2000);

        if (getFingerprintIDez() >= 0)
        {
            digitalWrite(buzzer, HIGH);
            delay(500);
            digitalWrite(buzzer, LOW);

            lcd.clear();
            lcd.print("Allowed");
            lcd.setCursor(0, 1);
            lcd.print("Vote Now");

            handleVoting();

            myServo.write(0);  // Open the servo
            delay(5000);
            myServo.write(180);  // Close the servo

            lcd.clear();
            lcd.print("Gate Closed");
        }
        delay(1000);
    }

    checkKeys();
    delay(500);  // Debounce delay
}

void handleVoting()
{
    lcd.clear();
    lcd.print("Vote: C1 C2 C3");

    while (true) 
    {
        if (digitalRead(candidate1) == LOW) 
        {
            voteCount1++;
            EEPROM.update(0, voteCount1);
            lcd.clear();
            lcd.print("Voted: Candidate 1");
            delay(2000);
            break;
        }
        else if (digitalRead(candidate2) == LOW) 
        {
            voteCount2++;
            EEPROM.update(1, voteCount2);
            lcd.clear();
            lcd.print("Voted: Candidate 2");
            delay(2000);
            break;
        }
        else if (digitalRead(candidate3) == LOW) 
        {
            voteCount3++;
            EEPROM.update(2, voteCount3);
            lcd.clear();
            lcd.print("Voted: Candidate 3");
            delay(2000);
            break;
        }
    }
}

void showResults()
{
    lcd.clear();
    lcd.print("Results:");
    lcd.setCursor(0, 1);
    lcd.print("C1:");
    lcd.print(voteCount1);
    lcd.setCursor(6, 1);
    lcd.print("C2:");
    lcd.print(voteCount2);
    lcd.setCursor(12, 1);
    lcd.print("C3:");
    lcd.print(voteCount3);
    delay(5000);
}

void checkKeys()
{
    if (digitalRead(enroll) == LOW)
    {
        lcd.clear();
        lcd.print("Please Wait");
        delay(1000);
        Enroll();
    }
    else if (digitalRead(del) == LOW)
    {
        lcd.clear();
        lcd.print("Please Wait");
        delay(1000);
        delet();
    }
    else if (digitalRead(resultbutton) == LOW)
    {
        showResults();
    }
}

void Enroll()
{
    int count = 0;
    lcd.clear();
    lcd.print("Enroll Finger");
    lcd.setCursor(0, 1);
    lcd.print("Location:");

    while (true)
    {
        lcd.setCursor(9, 1);
        lcd.print(count);

        if (digitalRead(up) == LOW)
        {
            count = (count + 1) % 25;  // Circular buffer
            delay(500);
        }
        else if (digitalRead(down) == LOW)
        {
            count = (count > 0) ? count - 1 : 24;
            delay(500);
        }
        else if (digitalRead(del) == LOW)
        {
            id = count;
            getFingerprintEnroll();
            return;
        }
        else if (digitalRead(enroll) == LOW)
        {
            return;
        }
    }
}

void delet()
{
    int count = 0;
    lcd.clear();
    lcd.print("Delete Finger");
    lcd.setCursor(0, 1);
    lcd.print("Location:");

    while (true)
    {
        lcd.setCursor(9, 1);
        lcd.print(count);

        if (digitalRead(up) == LOW)
        {
            count = (count + 1) % 25;
            delay(500);
        }
        else if (digitalRead(down) == LOW)
        {
            count = (count > 0) ? count - 1 : 24;
            delay(500);
        }
        else if (digitalRead(del) == LOW)
        {
            id = count;
            finger.deleteModel(id);  // Correct function to delete fingerprint
            return;
        }
        else if (digitalRead(enroll) == LOW)
        {
            return;
        }
    }
}

uint8_t getFingerprintEnroll()
{
    int p;
    lcd.clear();
    lcd.print("Finger ID:");
    lcd.print(id);
    lcd.setCursor(0, 1);
    lcd.print("Place Finger");

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

    finger.image2Tz(1);
    lcd.clear();
    lcd.print("Remove Finger");
    delay(2000);
    p = finger.image2Tz(2);
    if (p == FINGERPRINT_OK && finger.createModel() == FINGERPRINT_OK)
    {
        finger.storeModel(id);
    }
    return p;
}

int getFingerprintIDez()
{
    if (finger.getImage() != FINGERPRINT_OK || finger.image2Tz() != FINGERPRINT_OK || finger.fingerFastSearch() != FINGERPRINT_OK)
    {
        lcd.clear();
        lcd.print("Fingerprint Not Found");
        digitalWrite(buzzer, HIGH);
        delay(1000);
        digitalWrite(buzzer, LOW);
        delay(2000);
        return -1;
    }
    return finger.fingerID;
}

void handleFingerprintErrors(int errorCode)
{
    lcd.clear();
    if (errorCode == FINGERPRINT_NOFINGER)
        lcd.print("No Finger Detected");
    else if (errorCode == FINGERPRINT_PACKETRECIEVEERR)
        lcd.print("Communication Error");
    else if (errorCode == FINGERPRINT_IMAGEFAIL)
        lcd.print("Imaging Error");
    delay(1000);
}

Applications:

College and university election demonstrations
Secure polling prototype systems
Embedded systems academic projects
Biometric authentication learning projects
Science exhibitions and technology expos

This project demonstrates advanced embedded system concepts including serial communication with fingerprint modules, digital signal processing, real-time display management, and secure access control implementation. It provides a low-cost, scalable, and practical prototype for biometric electronic voting systems.

IOT & SMART SYSTEM PROJECTS

TRAFFIC & SMART CITY PROJECTS

ROBOTICS PROJECTS

LORA & WIRELESS COMMUNICATION PROJECTS

LED, LIGHTING & DISPLAY PROJECTS

SENSOR & DETECTION PROJECTS

FUN & INTERACTIVE PROJECTS

INDUSTRIAL / AUTOMATION PROJECTS

ROBOTICS

Search This Blog