PCB PROJECT

Electronic voting machine counter and keypad

interfacing

TEAM:
 Electronic voting machine counter and keypad
interfacing
In this project, our goal is to create a small system that Working principle
tallies the votes in an election and presents the results
The keypad interface allows users to input their
on an LCD display. The aim is to count the number of
choices. The numbers from 1 to 9 represent the
votes automatically and also to display the results
candidates, A stands for the voting officer, B resets the
when needed
machine for simulation, and C provides the results.
The components used are When the corresponding button is pressed, the
appropriate action will take place. Initially, the officer
• Arduino Uno: The main microcontroller board
must activate the voting process, so A should be
that controls the system and processes all
pressed. When a vote is cast for any candidate, the
inputs and outputs
LED lights up and a buzzer sounds to indicate that the
• 4×4 Matrix Keypad: Used for user input, vote has been successfully recorded. To check the vote
allowing voters to select candidates and count, button C can be pressed.
access functions like reset and results

• 16×2 LCD Display: Shows instructions, voting

Components specs and working
confirmations, and results to users
Here’s a detailed explanation of each component in
• Buzzer: Provides audio feedback when a vote
your Arduino voting machine project and the role it
is cast or an action is performed
plays:
• Connecting Wires: Used to connect all
1. Arduino Uno
components to the Arduino1
• Role: Acts as the brain of the system.
• Breadboard (optional): For easy prototyping
and organizing connections • Function: Processes all inputs from the
keypad, manages vote counting, controls the
• Power Supply or USB Cable: Powers the
LCD display and buzzer, and executes the
Arduino and the entire system
voting logic. It stores the vote counts in its
Simulation picture memory and updates them as votes are cast

Picture of Arduino uno

2. 4×4 Matrix Keypad 4. Buzzer

Picture of keypad Picture of buzzer

• Role: User input interface.

• Function: Allows voters and the voting officer • Role: Audio feedback.
to interact with the system.
• Function: Emits a beep sound to indicate a
o Keys 1–9: Each represents a successful vote, reset, or result display. This
candidate; pressing one casts a vote feedback assures users that their action has
for that candidate. been registered by the system45.

o A: Used by the voting officeto 5. Connecting Wires

authorize a vote
• Role: Electrical connections.
o B: Used to reset all vote counts.
• Function: Connect all components (keypad,
o C: Used to display the voting results LCD, buzzer) to the Arduino, allowing signals
on the LCD and power to flow between them

3. 16×2 LCD Display 6. Power Supply or USB Cable

Picture of lcd display • Role: Provides power.

• Function: Supplies the necessary voltage to

the Arduino and all connected components,
typically via USB or an external adapter

7. Breadboard (optional)

• Role: Prototyping platform.

• Role: Visual output interface. • Function: Makes it easy to connect and
• Function: Displays instructions, vote organize components during assembly and
confirmation, and the results. It helps voters testing, without soldering
know their vote has been registered and
allows officials to see the current tally or reset
confirmation
Arduino code : lcd.print("EVM System");

#include <Keypad.h> delay(2000);

#include <Wire.h> lcd.clear();

#include <LiquidCrystal_I2C.h>

pinMode(greenLedPin, OUTPUT);

// I2C address for LCD (change 32 to 0x27 or 0x3F if pinMode(buzzerPin, OUTPUT);

needed)
digitalWrite(greenLedPin, LOW);
LiquidCrystal_I2C lcd(32, 16, 2);
digitalWrite(buzzerPin, LOW);

}
const byte numRows = 4;

const byte numCols = 4;

void loop() {

char key = keypad.getKey();

char keymap[numRows][numCols] = {
if (key) {
{'1', '2', '3', 'A'},
if (key >= '1' && key <= '9') {
{'4', '5', '6', 'B'},
int candidate = key - '0';
{'7', '8', '9', 'C'},
if (votingEnabled) {
{'*', '0', '#', 'D'}
votes[candidate]++;
};
lcd.clear();

lcd.setCursor(0, 0);
byte rowPins[numRows] = {9, 8, 7, 6};
lcd.print("Voted for: ");
byte colPins[numCols] = {5, 4, 3, 2};
lcd.print(candidate);

digitalWrite(greenLedPin, HIGH);
Keypad keypad = Keypad(makeKeymap(keymap),
digitalWrite(buzzerPin, HIGH); // Buzzer ON
rowPins, colPins, numRows, numCols);
delay(500); // Buzz duration

digitalWrite(buzzerPin, LOW); // Buzzer OFF

int votes[10] = {0}; // votes[1] to votes[9]
votingEnabled = false;
bool votingEnabled = false;
delay(1500);

lcd.clear();
const int greenLedPin = 11;
digitalWrite(greenLedPin, LOW);
const int buzzerPin = 12;
} else {

lcd.clear();
void setup() {
lcd.print("Wait for Officer");
lcd.init();
delay(1500);
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
 } Pin specification and working:

} else if (key == 'A') {

Keypad Connection Pins
votingEnabled = true;
• Row Pins (9, 8, 7, 6): Connect to the four
lcd.clear();
rows of the 4×4 matrix keypad.
lcd.print("Voter Enabled"); • Column Pins (5, 4, 3, 2): Connect to the
delay(1500); four columns of the keypad.

lcd.clear(); This connection allows the Arduino to detect

which button is pressed by scanning the rows
} else if (key == 'B') {
and columns. When a key is pressed, it
for (int i = 1; i <= 9; i++) { connects a specific row with a specific column,
creating a unique position that can be mapped
votes[i] = 0;
to the keypad matrix values (1-9, A-D, *, #)
}

lcd.clear(); I2C LCD Connection

lcd.print("Votes Reset"); • The LCD uses I2C communication, which

requires just two data pins:
delay(1500);
o SDA (Serial Data): Connected to
lcd.clear(); Arduino's A4 pin (not explicitly
shown in code)
} else if (key == 'C') {
o SCL (Serial Clock): Connected to
lcd.clear(); Arduino's A5 pin (not explicitly
lcd.print("Results:");
shown in code)
• The LCD address is set to 32 in the code
delay(1000); (this may need to be changed to 0x27 or
for (int i = 1; i <= 9; i++) { 0x3F depending on your specific LCD
module)
lcd.clear();

lcd.setCursor(0, 0); Output Pins

lcd.print("Cand "); • Green LED (Pin 11): Lights up when a

lcd.print(i); vote is successfully cast, providing visual
confirmation.
lcd.print(": "); • Buzzer (Pin 12): Provides audio
lcd.print(votes[i]); feedback when a vote is registered

delay(1500);

lcd.clear();

}
Function of Each Pin Picture of 3d view
The row and column pins work together to
create a matrix that

identifies exactly which key is pressed. The

Arduino sets each row pin LOW one at a time
while reading the column pins. When a button
is pressed, it connects a row to a column,
allowing the Arduino to determine which key
was pressed by detecting which row and
column are connected
This pin configuration follows standard
practice for Arduino-based electronic voting
machines, creating an efficient interface with
minimal pin usage while supporting the full
functionality of the voting system

Application
• Educational Institutions: This
Arduino-based voting machine is ideal
Picture of pcb schematic for student council elections, classroom
polls, or any educational setting where a
simple, transparent voting process is
needed
• Small-Scale Elections: Suitable for local
bodies, clubs, societies, or community
groups to conduct quick and fair
elections without the complexity and
cost of traditional ballot systems
• Demonstration and Training: Useful
Picture of 2d view for demonstrating the principles of
electronic voting, automation, and
microcontroller interfacing in
workshops and academic labs
• Cost-Effective Voting Solution: It
provides a low-cost alternative to paper-
based voting, reducing the need for
manpower and minimizing errors in
vote counting
Conclusion:
• The Arduino-based electronic voting machine offers a simple, efficient, and
transparent way to conduct elections on a small scale.
• By automating vote collection and counting, it eliminates common issues found
in manual voting systems, such as counting errors and fraudulent practices The
system is user-friendly, easy to set up, and provides instant results at the press of
a button, as displayed on the LCD.
• While it is best suited for educational and small community applications, the
project demonstrates the potential of microcontroller-based solutions in
improving the reliability and speed of electoral processes.
• For larger-scale or high-security elections, additional features like biometric
authentication or blockchain integration can further enhance security and trust
in the system