Engineers Garage

  • Projects and Tutorials
    • Circuit Design
    • Electronic Projects
      • 8051
      • Arduino
      • ARM
      • AVR
      • PIC
      • Raspberry pi
      • STM32
    • Tutorials
    • Components
  • Contributions
  • Articles
    • EG Blogs
    • Insight
    • Invention Stories
    • How to
  • What Is
  • Forums
    • EG Forum Archive
    • EDABoard.com
    • Electro-Tech-Online
  • Digi-Key Store
    • Cables, Wires
    • Connectors, Interconnect
    • Discrete
    • Electromechanical
    • Embedded Computers
    • Enclosures, Hardware, Office
    • Integrated Circuits (ICs)
    • Isolators
    • LED/Optoelectronics
    • Passive
    • Power, Circuit Protection
    • Programmers
    • RF, Wireless
    • Semiconductors
    • Sensors, Transducers
    • Test Products
    • Tools
  • News
    • EE Design News
    • DIY Reviews
    • Guest Post
    • Sponsored Content
  • EE Resources
    • DesignFast
    • LEAP Awards
    • Oscilloscope Product Finder
    • White Papers
    • Webinars
  • EE Classrooms
    • Grid Infrastructure
    • Aerospace & Defense
    • Building Automation
    • Power Delivery
    • Factory Automation
    • Motor Drives
    • Medical Technology
  • Video

Electronic Voting Machine using Internal EEPROM of AVR

June 25, 2013 By Ashutosh Bhatt

The microcontroller based voting machines made the process of voting and counting the voted lot easier than before. Previously the votes were marked in paper which are then stored safely in a box and inside a well secure room for days. The process of separating the votes and counting them manually may take a lot of days. But after finding the electronic voting machine the votes can be marked without using papers, which makes the voting process eco-friendly. Moreover it makes the counting process faster and the results can be announced in a comparatively shorter period of time. 

There should be a controller inside the Electronic Voting Machine (EVM) which controls the process and there should be storage medium where the details of the vote are stored. There should be a ballet unit which is been used in such a way that the one who came to cast the vote can do only one vote. There should be a keypad also which can be used by those who wish to cast a vote. In this project the AVR microcontroller is used to demonstrate the working of a simplest voting machine which can communicate with a PC serially and which can store the count of votes in its internal memory.

 


 

This project is all about how we can make use of internal EEPROM of the AVR for storing data for future purpose. In this project we are making an Electronic Voting Machine (EVM) using the EEPROM of the AVR. As in the case of normal EVM, there is a control unit and a ballet unit. The ballet unit can be used to cast the vote only after it is enabled by pressing a key in the control unit. After casting a single vote the ballet unit will get disabled again. Each and every time a user press a key the LCD displays which candidate he voted for.

The interesting part is that each and every time a vote being casted, the count will get updated automatically in the internal EEPROM. Hence once the polling is done we can disconnect the unit from power supply and keep it safe till the day of counting. We can power up the board and even after a long period of time we can read out the number of votes casted for each candidate by connecting the EVM to the through HyperTerminal via serial communication with AVR. 

 

Project Source Code

###


#define F_CPU 8000000
 
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include "lcd.h"
#include "usart.h"
 
void switch_init ( void );
void led_init ( void );
void evm_init ( void );
void evm_raedy_wait ( void );
void evm_vote ( void );
char read_key_wait ( void );
void update_count ( int candidate_address );
void send_count_out ( void );
void reset_count ( void );
 
int main ( void )
{
char poll_result_mode = 1;
evm_init ();
 
MENU:
//-----------------------------------------//
stdout = &lcd_out;
lcd_clear ();
printf ( "A-POLL B-COUNT");
printf ( "nRESET COUNT-C" );
//-----------------------------------------//
 
poll_result_mode = read_key_wait ();   // wait till any key is pressed 
                 // and read the current key pad value
switch ( poll_result_mode )
{
case 0:
while ( 1 )
{
evm_raedy_wait ();
evm_vote ();
}
goto MENU;
case 1:
send_count_out ();
goto MENU;
 
case 2:
reset_count ();
goto MENU;
}
 
while ( 1 );
}
void switch_init ( void )
{
cli();
DDRC &= 0xE0;
PORTC = 0xFF;
DDRD |= 0x80;
PORTD |= 0x80;
sei();
}
 
void led_init ( void )
{
cli();
DDRD |= 0x80;
PORTD |= 0x80;
sei();
}
 
void evm_init ()
{
led_init ();
switch_init ();
usart_init();
lcd_init ();
}
 
void evm_raedy_wait ( void )
{
lcd_clear ();
printf ( "_______EVM______" );
//============ wait till evm unit enabled by external switch ===============//
while ( ( PINC & 0x10 ) );
_delay_ms ( 50 );
while ( !( PINC & 0x10 ) );
PORTD &= 0x7F;
//============ wait till evm unit enabled by external switch ===============//
lcd_clear ();
printf ( "YOU CAN VOTE NOW" );
}
 
char read_key_wait ( void )
{
char button;
 
while ( 0x0F == ( button = ( PINC & 0x0F ) ) );   // wait till any key is pressed 
 // and read the current key pad value
_delay_ms ( 50 );
 
switch ( button )
{
case 0x0B:
return 0;
 
case 0x07:
return 1;
 
case 0x0D:
return 2;
 
case 0x0E:
return 3;
};
 
return 0;
}
 
void evm_vote ( void )
{
char button;
 
button = read_key_wait ();   // wait till any key is pressed 
 // and read the current key pad value
switch ( button )
{
case 0:
update_count ( 0 );
lcd_clear ();
printf ( "You voted for A" );
break;
 
case 1:
update_count ( 1 );
lcd_clear ();
printf ( "You voted for B" );
break;
 
case 2:
update_count ( 2 );
lcd_clear ();
printf ( "You voted for C" );
break;
 
case 3:
update_count ( 3 );
lcd_clear ();
printf ( "You voted for D" );
break;
};
 
PORTD |= 0x80;
_delay_ms ( 3000 );
}
 
void update_count ( int candidate_address )
{
int base_address = 100;
int count = 0;
 
count = eeprom_read_byte ( ( unsigned char * ) ( base_address + candidate_address ) );
count ++;
eeprom_write_byte ( ( unsigned char * ) ( base_address + candidate_address ), count );
}
 
void send_count_out ( void )
{
int base_address = 100;
int i = 0;
 
stdout = &uart_out;
printf ( "n______________________EVM______________________" );
 
for ( i = 0; i < 4; i ++ )
printf ( "nCANDIDATE : %c, NO. VOTES : %d", ( 'A' + i ), eeprom_read_byte ( ( unsigned char * ) ( base_address + i ) ) );
}
 
void reset_count ( void )
{
int base_address = 100;
int i = 0;
for ( i = 0; i < 4; i ++ )
eeprom_write_byte ( ( unsigned char * ) ( base_address + i ), 0 );
 
lcd_clear ();
printf ( "RESET [OK]");
_delay_ms ( 2000 );
}

########## LCD ##########

#ifndef _LCD_H
#define _LCD_H
 
#ifndef F_CPU
#define F_CPU 8000000
#endif
 
#include<avr/io.h>
#include<util/delay.h>
#include<inttypes.h>
#include <stdio.h>
#include <string.h>
 
#define rs PA0
#define rw PA1
#define en PA2
 
void lcd_init();
void dis_cmd(char);
void dis_data(char);
void lcdcmd(char);
void lcddata(char);
void lcd_clear(void);
void lcd_2nd_line(void);
void lcd_1st_line(void);
void lcd_string(const char *data);
int lcd_print(char c, FILE *stream);
int lcd_scroll(const char *data);
 
FILE lcd_out = FDEV_SETUP_STREAM(lcd_print, NULL,
                                         _FDEV_SETUP_WRITE);
 
char disp_beg [] = "                ";
 
int lcd_print(char c, FILE *stream)
{
  if('n' == c)
  lcd_2nd_line();
  else
    dis_data(c);
 
  return 0;
}
 
int lcd_scroll(const char *data)
{
int i;
int j = 0;
 
strcat(disp_beg, data);
 
for(i = 0; i < 14; i ++)
strcat(disp_beg, " ");
 
while(1)
{
for(i = 0;i < 16;i ++)
{
if(!disp_beg[i + j])
return 0;
else;
 
dis_data(disp_beg [i + j]);
}
j ++;
_delay_ms(500);
lcd_clear ();
}
 
return 0;
}
 
void lcd_string(const char *data)
{
for(;*data;data++)
dis_data (*data);
}
 
void lcd_clear(void)
{
dis_cmd(0x01);
_delay_ms(10);
}
 
void lcd_2nd_line(void)
{
dis_cmd(0xC0);
_delay_ms(1);
}
 
void lcd_1st_line(void)
{
dis_cmd(0x80);
_delay_ms(1);
}
 
void lcd_init() // fuction for intialize 
{
DDRA=0xFF;
dis_cmd(0x02); // to initialize LCD in 4-bit mode.
dis_cmd(0x28); //to initialize LCD in 2 lines, 5X7 dots and 4bit mode.
dis_cmd(0x0C);
dis_cmd(0x06);
dis_cmd(0x80);
dis_cmd(0x01);
_delay_ms(500);
    stdout = &lcd_out;
}
 
void dis_cmd(char cmd_value)
{
char cmd_value1;
cmd_value1 = cmd_value & 0xF0; //mask lower nibble because PA4-PA7 pins are used. 
lcdcmd(cmd_value1); // send to LCD
 
cmd_value1 = ((cmd_value<<4) & 0xF0); //shift 4-bit and mask
lcdcmd(cmd_value1); // send to LCD
}
 
 
void dis_data(char data_value)
{
char data_value1;
data_value1=data_value&0xF0;
lcddata(data_value1);
 
data_value1=((data_value<<4)&0xF0);
lcddata(data_value1);
}
 
void lcdcmd(char cmdout)
{
PORTA=cmdout;
PORTA&=~(1<<rs);
PORTA&=~(1<<rw);
PORTA|=(1<<en);
_delay_ms(1);
PORTA&=~(1<<en);
}
 
void lcddata(char dataout)
{
PORTA=dataout;
PORTA|=(1<<rs);
PORTA&=~(1<<rw);
PORTA|=(1<<en);
_delay_ms(1);
PORTA&=~(1<<en);
}
 
#endif
 
 

###

 


Project Source Code

###


#ifndef _USART_H
#define _USART_H
 
#ifndef F_CPU
#define F_CPU 8000000
#endif
 
#define USART_BAUDRATE 9600
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
 
#include<avr/io.h>
#include<util/delay.h>
#include <stdio.h>
 
void usart_init();
void usart_putch(unsigned char send);
unsigned int usart_getch();
void usart_send_string(const char* data);
int uart_print(char c, FILE *stream);
 
FILE uart_out = FDEV_SETUP_STREAM(uart_print, NULL,
                                         _FDEV_SETUP_WRITE);
 
int uart_print(char c, FILE *stream)
{
 
  if (c == 'n')
    uart_print('r', stream);
  loop_until_bit_is_set(UCSRA, UDRE);
  UDR = c;
  return 0;
}
 
void usart_init()
{
UCSRB |= (1 << RXEN) | (1 << TXEN);   
// Turn on the transmission and reception circuitry
UCSRC |= (1 << URSEL) | (1<<USBS) | (1 << UCSZ0) | (1 << UCSZ1); 
// Use 8-bit character sizes
 
UBRRL = BAUD_PRESCALE; // Load lower 8-bits of the baud rate value..
// into the low byte of the UBRR register
UBRRH = (BAUD_PRESCALE >> 8); // Load upper 8-bits of the baud rate value..
// into the high byte of the UBRR register
 
stdout = &uart_out;
}
 
void usart_putch(unsigned char send)
{
while ((UCSRA & (1 << UDRE)) == 0); // Do nothing until UDR is ready..
// for more data to be written to it
UDR = send; // Send the byte 
}
 
unsigned int usart_getch()
{
while ((UCSRA & (1 << RXC)) == 0);
// Do nothing until data have been received and is ready to be read from UDR
return(UDR); // return the byte
}
 
void usart_send_string(const char* data)
{
for(; *data; data ++)
usart_putch(*data);
}
 
#endif

###

 


Circuit Diagrams

circuit

Project Components

  • ATmega16
  • LCD
  • Resistor

Project Video

Related Articles Read More >

LCD Scrolling Display Module using AVR controller and 16x2 alphanumeric LCD display setup on breadboard
LCD Scrolling Display Module- (Part 30/46)
Wrting Simple Boot-Loader code for AVR microcontroller in C to Initialize peripherals circuit set up on breadboard
How To Write a Simple Bootloader For AVR In C language- (Part 35/46)
How To Use SPM To load Application from EEPROM
How To Use SPM To load Application from EEPROM- (Part 34/46)
Configuring SPM of AVR for Flash to Flash Programming Circuit Setp up on breadboard
How to Use SPM for Flash to Flash Programming- (Part 33/46)

Stay Up To Date

Newsletter Signup

Popular Posts

Tic Tac Toe Multiplayer game in c++
Making blinking pattern of leds with 8051 microcontroller
properties of inductors
Basic Electronics 19 – Properties of inductors
GLCD 128×64 graphical lcd(GLCD) interfacing with 8051(89c51,89c52) microcontroller

EE Training Center Classrooms

“ee
“ee

Recent Articles

  • Renesas Electronics secures Bluetooth 5 connections with 32-bit RX23W MCU
  • iBASE introduces signaturePro 12-Port video wall signage player with outstanding capabilities
  • Microcontroller Project: STM32 low power modes analysis
  • Fujitsu starts shipping supercomputer Fugaku
  • RPi Python Programming 03 – Raspberry Pi as Linux System
Engineers Garage
  • Analog IC TIps
  • Connector Tips
  • DesignFast
  • EDABoard Forums
  • EE World Online
  • Electro-Tech-Online Forums
  • Microcontroller Tips
  • Power Electronic Tips
  • Sensor Tips
  • Test and Measurement Tips
  • About Us
  • Contact Us
  • Advertise

Copyright © 2019 WTWH Media LLC. All Rights Reserved. The material on this site may not be reproduced, distributed, transmitted, cached or otherwise used, except with the prior written permission of WTWH Media
Privacy Policy | Advertising | About Us

Search Engineers Garage

  • Projects and Tutorials
    • Circuit Design
    • Electronic Projects
      • 8051
      • Arduino
      • ARM
      • AVR
      • PIC
      • Raspberry pi
      • STM32
    • Tutorials
    • Components
  • Contributions
  • Articles
    • EG Blogs
    • Insight
    • Invention Stories
    • How to
  • What Is
  • Forums
    • EG Forum Archive
    • EDABoard.com
    • Electro-Tech-Online
  • Digi-Key Store
    • Cables, Wires
    • Connectors, Interconnect
    • Discrete
    • Electromechanical
    • Embedded Computers
    • Enclosures, Hardware, Office
    • Integrated Circuits (ICs)
    • Isolators
    • LED/Optoelectronics
    • Passive
    • Power, Circuit Protection
    • Programmers
    • RF, Wireless
    • Semiconductors
    • Sensors, Transducers
    • Test Products
    • Tools
  • News
    • EE Design News
    • DIY Reviews
    • Guest Post
    • Sponsored Content
  • EE Resources
    • DesignFast
    • LEAP Awards
    • Oscilloscope Product Finder
    • White Papers
    • Webinars
  • EE Classrooms
    • Grid Infrastructure
    • Aerospace & Defense
    • Building Automation
    • Power Delivery
    • Factory Automation
    • Motor Drives
    • Medical Technology
  • Video