Macchina per il voto elettronico con modulo SD Card

In questo post costruiremo un circuito per una macchina per il voto elettronico utilizzando Arduino e il modulo della scheda SD in cui i dati delle elezioni sono memorizzati nella scheda SD.

Di

AGGIORNARE:

Questo circuito è stato aggiornato a una versione migliorata in cui i risultati possono essere visualizzati su un display LCD allegato, puoi ottenere i dettagli nella sezione inferiore del post

Utilizzo del display LCD 16x2

Un display 16 x 2 mostra lo stato della macchina di voto e quando si vota, verrà visualizzato il nome del candidato insieme all'attivazione del LED e del buzzer.

Nota: il progetto proposto è realizzato solo a scopo educativo e non è inteso per uso elettorale reale.

Le macchine per il voto elettronico sono implementate per velocizzare il processo elettorale e ridurre l'uso di carta e questi motivi riducono indirettamente le spese relative alle elezioni.

Le macchine per il voto elettronico forniscono una sicurezza superiore prima del tradizionale metodo di voto cartaceo.

Il trasporto di queste urne alla rinfusa è rischioso rispetto al trasporto di macchine compatte, dove le frodi sulla cattura dei veicoli non possono alterare i dati nell'EVM (Macchina per il voto elettronico) anche se in grado di catturare il veicolo.

Alcuni paesi mostrano interesse per gli EVM di fabbricazione indiana a causa della sicurezza superiore. Paesi come gli Stati Uniti continuano ad attenersi al tradizionale metodo di voto cartaceo per le loro elezioni a causa del rischio maggiore di hackerare e alterare i dati elettorali.

Allora, cosa ha reso gli indiani EVM più sicuri? Bene, gli Stati Uniti hanno creato macchine per il voto caricate con il sistema operativo Windows e collegate in rete con i server per facilitare il conteggio dei voti. Questo apre molte scappatoie agli hacker per modificare i dati elettorali.

Gli EVM di fabbricazione indiana sono dispositivi autonomi e non connessi a Internet o ai server. Per il conteggio dei voti le macchine vengono portate alla cabina di conteggio, dove verranno dichiarati i risultati e nessun intermediario.

Il progetto proposto è progettato con funzionalità simili a quelle degli EVM indiani, ma sono state apportate molte modifiche.

Passiamo ora ai dettagli costruttivi del progetto.

Layout del circuito:

Il circuito EVM proposto può ospitare solo 6 candidati. Viene fornito un pulsante di controllo simile all'unità di controllo negli EVM reali. Dopo che una persona ha espresso il proprio voto, i pulsanti di votazione vengono disabilitati.

I pulsanti di scrutinio vengono nuovamente abilitati solo dopo aver premuto il pulsante di controllo. Il pulsante di controllo sarà posizionato vicino al responsabile che controlla la cabina elettorale.

Dopo che una persona ha espresso un voto, viene confermata con l'attivazione del LED e del buzzer. La persona può anche confermare il voto a chi ha espresso sul display, mostrerà il nome del candidato o il nome del partito per un paio di secondi. Questa caratteristica non è ancora presente nei veri EVM.

Diagramma schematico:

Arduino che mostra la connettività:

Il circuito è diviso in due parti per evitare confusioni durante la duplicazione del progetto. Il circuito sopra descrive il cablaggio tra il display LCD e arduino. Regolare la resistenza variabile per un contrasto ottimale.

Ecco il resto del circuito composto da batteria da 9 V, interruttore, sette pulsanti, LED, cicalino e, soprattutto, modulo scheda SD.

La scheda SD memorizzerà i dati immediatamente dopo che è stata espressa una votazione. Una volta che l'elezione è finita, la scheda SD viene inserita in un computer per dichiarare il conteggio dei voti e il risultato.

Il progetto proposto può registrare fino a 4.294.967.295 (che è più di 4 miliardi) di voti per candidato e 25.769.803.770 (più di 25 miliardi che è più del triplo della popolazione mondiale attuale) voti per macchina e ancora più del 99,9% della scheda SD è ancora vuota .

Questo è molto più efficiente dei veri EVM che possono registrare 3840 voti per macchina.

Programma:

//--------Program Developed by R.Girish------//
#include
#include
#include
LiquidCrystal lcd(7, 6, 5, 4, 3, 2)
//----------------------------------------------------//
String Party1 = 'MODI'
String Party2 = 'TRUMP'
String Party3 = 'PUTIN' // Place the Candidate Names Here.
String Party4 = 'Abdul Kalam'
String Party5 = 'Girish'
String Party6 = 'Swagatam'
//-----------------------------------------------------//
const int btn_1 = A0
const int btn_2 = A1
const int btn_3 = A2
const int btn_4 = A3
const int btn_5 = A4
const int btn_6 = A5
const int ctrl_btn = 8
const int cs = 10
const int LED = 9
boolean ballot = false
File Party1File
File Party2File
File Party3File
File Party4File
File Party5File
File Party6File
unsigned long int Party1_Count = 0
unsigned long int Party2_Count = 0
unsigned long int Party3_Count = 0
unsigned long int Party4_Count = 0
unsigned long int Party5_Count = 0
unsigned long int Party6_Count = 0
void setup()
{
pinMode(btn_1,INPUT)
pinMode(btn_2,INPUT)
pinMode(btn_3,INPUT)
pinMode(btn_4,INPUT)
pinMode(btn_5,INPUT)
pinMode(btn_6,INPUT)
pinMode(ctrl_btn,INPUT)
pinMode(cs,OUTPUT)
pinMode(LED,OUTPUT)
digitalWrite(btn_1,HIGH)
digitalWrite(btn_2,HIGH)
digitalWrite(btn_3,HIGH)
digitalWrite(btn_4,HIGH)
digitalWrite(btn_5,HIGH)
digitalWrite(btn_6,HIGH)
digitalWrite(ctrl_btn,HIGH)
lcd.begin(16,2)
lcd.clear()
lcd.setCursor(0,0)
lcd.print(' Electronic')
lcd.setCursor(0,1)
lcd.print(' Voting Machine')
delay(2000)
if (!SD.begin(cs))
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('SD Card failed')
lcd.setCursor(0,1)
lcd.print('or not present')
while(true)
{
digitalWrite(LED, HIGH)
delay(100)
digitalWrite(LED, LOW)
delay(100)
}
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Machine Status:')
lcd.setCursor(0,1)
lcd.print('Initialized !!!')
digitalWrite(LED,HIGH)
delay(2000)
digitalWrite(LED,LOW)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Machine is ready')
lcd.setCursor(0,1)
lcd.print('----------------')
while(!ballot)
{
if(digitalRead(ctrl_btn) == LOW)
{
ballot = true
for(int y = 0 y <3 y++)
{
digitalWrite(LED, HIGH)
delay(100)
digitalWrite(LED, LOW)
delay(100)
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Cast Your Vote')
lcd.setCursor(0,1)
lcd.print('----------------')
}
}
}
void loop()
{
while(ballot)
{
if(digitalRead(btn_1) == LOW)
{
Party_1()
}
if(digitalRead(btn_2) == LOW)
{
Party_2()
}
if(digitalRead(btn_3) == LOW)
{
Party_3()
}
if(digitalRead(btn_4) == LOW)
{
Party_4()
}
if(digitalRead(btn_5) == LOW)
{
Party_5()
}
if(digitalRead(btn_6) == LOW)
{
Party_6()
}
}
}
void Party_1()
{
ballot = false
SD.remove('Party1.txt')
Party1File = SD.open('Party1.txt', FILE_WRITE)
if(Party1File)
{
Party1_Count = Party1_Count + 1
lcd.clear()
lcd.setCursor(0,0)
lcd.print('You voted for:')
lcd.setCursor(0,1)
lcd.print(Party1)
Party1File.println('------------------------------------')
Party1File.print('Result for: ')
Party1File.println(Party1)
Party1File.print('------------------------------------')
Party1File.println(' ')
Party1File.print('Number of Votes = ')
Party1File.print(Party1_Count)
Party1File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_2()
{
ballot = false
SD.remove('Party2.txt')
Party2File = SD.open('Party2.txt', FILE_WRITE)
if(Party2File)
{
Party2_Count = Party2_Count + 1
lcd.clear()
lcd.setCursor(0,0)
lcd.print('You voted for:')
lcd.setCursor(0,1)
lcd.print(Party2)
Party2File.println('------------------------------------')
Party2File.print('Result for: ')
Party2File.println(Party2)
Party2File.print('------------------------------------')
Party2File.println(' ')
Party2File.print('Number of Votes = ')
Party2File.print(Party2_Count)
Party2File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_3()
{
ballot = false
SD.remove('Party3.txt')
Party3File = SD.open('Party3.txt', FILE_WRITE)
if(Party3File)
{
Party3_Count = Party3_Count + 1
lcd.clear()
lcd.setCursor(0,0)
lcd.print('You voted for:')
lcd.setCursor(0,1)
lcd.print(Party3)
Party3File.println('------------------------------------')
Party3File.print('Result for: ')
Party3File.println(Party3)
Party3File.print('------------------------------------')
Party3File.println(' ')
Party3File.print('Number of Votes = ')
Party3File.print(Party3_Count)
Party3File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_4()
{
ballot = false
SD.remove('Party4.txt')
Party4File = SD.open('Party4.txt', FILE_WRITE)
if(Party4File)
{
Party4_Count = Party4_Count + 1
lcd.clear()
lcd.setCursor(0,0)
lcd.print('You voted for:')
lcd.setCursor(0,1)
lcd.print(Party4)
Party4File.println('------------------------------------')
Party4File.print('Result for: ')
Party4File.println(Party4)
Party4File.print('------------------------------------')
Party4File.println(' ')
Party4File.print('Number of Votes = ')
Party4File.print(Party4_Count)
Party4File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_5()
{
ballot = false
SD.remove('Party5.txt')
Party5File = SD.open('Party5.txt', FILE_WRITE)
if(Party5File)
{
Party5_Count = Party5_Count + 1
lcd.clear()
lcd.setCursor(0,0)
lcd.print('You voted for:')
lcd.setCursor(0,1)
lcd.print(Party5)
Party5File.println('------------------------------------')
Party5File.print('Result for: ')
Party5File.println(Party5)
Party5File.print('------------------------------------')
Party5File.println(' ')
Party5File.print('Number of Votes = ')
Party5File.print(Party5_Count)
Party5File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_6()
{
ballot = false
SD.remove('Party6.txt')
Party6File = SD.open('Party6.txt', FILE_WRITE)
if(Party6File)
{
Party6_Count = Party6_Count + 1
lcd.clear()
lcd.setCursor(0,0)
lcd.print('You voted for:')
lcd.setCursor(0,1)
lcd.print(Party6)
Party6File.println('------------------------------------')
Party6File.print('Result for: ')
Party6File.println(Party6)
Party6File.print('------------------------------------')
Party6File.println(' ')
Party6File.print('Number of Votes = ')
Party6File.print(Party6_Count)
Party6File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Error()
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Unable to log')
lcd.setCursor(0,1)
lcd.print('data to SD card')
for(int x = 0 x <100 x++)
{
digitalWrite(LED, HIGH)
delay(250)
digitalWrite(LED, LOW)
delay(250)
}
}
void Tone()
{
digitalWrite(LED, HIGH)
delay(1000)
digitalWrite(LED, LOW)
delay(1500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print(' Thanks for')
lcd.setCursor(0,1)
lcd.print(' Voting!!!')
delay(1500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print(' Not Ready')
lcd.setCursor(0,1)
lcd.print('----------------')
}
void ctrl()
{
while(!ballot)
{
if(digitalRead(ctrl_btn) == LOW)
{
ballot = true
for(int y = 0 y <3 y++)
{
digitalWrite(LED, HIGH)
delay(100)
digitalWrite(LED, LOW)
delay(100)
}
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Cast Your Vote')
lcd.setCursor(0,1)
lcd.print('----------------')
}
}
}
//--------Program Developed by R.Girish------//
……… Questo è un programma enorme.

Come utilizzare questo circuito EVM:

• Accendere la macchina, si confermerà con un segnale acustico che indica che tutto va bene. Se la macchina non funziona, emette rapidamente un segnale acustico e visualizza il messaggio di errore sul display LCD.
• Premere il pulsante di controllo, ora è pronto per registrare un voto.
• Una volta registrato il voto, si attiverà il LED, emetterà un segnale acustico per un secondo e visualizzerà per un paio di secondi il nome del candidato a cui si è votato.
• Per registrare il voto successivo, premere nuovamente il pulsante di controllo. Ogni volta che si preme il pulsante di controllo, il cicalino emette 3 brevi bip.
• Questo deve essere continuato fino a quando l'ultimo elettore ha espresso il proprio voto. Non c'è bisogno di premere il pulsante di controllo dopo che l'ultimo elettore ha deciso di votare.
• Dopo che è stata espressa l'ultima votazione, la macchina deve essere spenta immediatamente utilizzando l'interruttore di spegnimento e la scheda SD deve essere rimossa. In modo che nessun dato venga alterato.
• Collega la scheda SD a un computer e puoi vedere 6 file di testo come mostrato di seguito:

L'apertura di un file mostrerà il nome del candidato e il numero di voti, come illustrato di seguito:

Prototipo dell'autore:

Illustrazione del modulo della scheda SD:

Nota 1: qualsiasi interruzione dell'alimentazione riporterà a zero il conteggio dei voti.
Nota 2: modificare il nome del candidato nel programma.
String Party1 = 'MODI'
String Party2 = 'TRUMP'
String Party3 = 'PUTIN' // Posiziona qui i nomi dei candidati.
String Party4 = 'Abdul Kalam'
String Party5 = 'Girish'
String Party6 = 'Swagatam'
Nota 3: se non viene espresso alcun voto a un determinato partito / candidato, il file di testo non verrà visualizzato nella scheda SD.

Aggiornamento del design precedente

Questa particolare versione aggiornata del progetto della macchina per il voto elettronico è stata richiesta da Sumesh chourasia, che è un avido lettore di questo sito web.

Questo progetto è un miglioramento rispetto alla macchina per il voto elettronico spiegato sopra. Lo svantaggio principale della suddetta EVM (Electronic Voting Machine) era che il risultato non poteva essere visualizzato sul display LCD 16 x 2, ma può essere visualizzato solo sul computer.

In questo progetto stiamo abbattendo i richiami menzionati e con il nuovo design proposto possiamo visualizzare istantaneamente il risultato dei 6 candidati sul display LCD.

Difficoltà che abbiamo incontrato:

Tutti i pin di input / output (di Arduino) del precedente progetto EVM erano utilizzati dal display 16 x 2, dal modulo della scheda SD, dai pulsanti di voto, dal pulsante di controllo e dal cicalino. Non c'è più spazio per collegare un nuovo pulsante.

Dopo alcune ricerche abbiamo scoperto che qualsiasi pin I / O può essere modificato in output in input e viceversa in qualsiasi momento.

Dopo un'attenta osservazione abbiamo scelto il pin LED / buzzer come pulsante di salvataggio. Ora questo pin è programmato sia come input (pulsante di salvataggio) che come output (buzzer).

Si noti che il pin di salvataggio / cicalino è assegnato a uno qualsiasi degli stati in un istante, ad esempio uscita o ingresso.

Il circuito:

Connessione LCD ad Arduino:

Basta collegare come per gli schemi precedenti e utilizzare il potenziometro 10K per regolare il contrasto di visualizzazione, il resto del circuito si spiega da sé.

Da S1 a S6 sono pulsanti di voto attraverso i quali gli elettori inseriscono la loro scelta. Il pulsante di salvataggio e controllo deve essere tenuto lontano dall'unità di scrutinio (sotto il controllo della cabina elettorale incaricata).

Nuovo programma:
//--------Program Developed by R.Girish------//
#include
#include
#include
LiquidCrystal lcd(7, 6, 5, 4, 3, 2)
//----------------------------------------------------//
String Party1 = 'MODI'
String Party2 = 'TRUMP'
String Party3 = 'PUTIN' // Place the Candidate Names Here.
String Party4 = 'Abdul Kalam'
String Party5 = 'Girish'
String Party6 = 'Swagatam'
//-----------------------------------------------------//
const int btn_1 = A0
const int btn_2 = A1
const int btn_3 = A2
const int btn_4 = A3
const int btn_5 = A4
const int btn_6 = A5
const int ctrl_btn = 8
const int cs = 10
int LED = 9
int saveTest = 0
int A = 0
int B = 0
int C = 0
int D = 0
int E = 0
int F = 0
boolean ballot = false
File Party1File
File Party2File
File Party3File
File Party4File
File Party5File
File Party6File
File save
unsigned long int Party1_Count = 0
unsigned long int Party2_Count = 0
unsigned long int Party3_Count = 0
unsigned long int Party4_Count = 0
unsigned long int Party5_Count = 0
unsigned long int Party6_Count = 0
void setup()
{
pinMode(btn_1, INPUT)
pinMode(btn_2, INPUT)
pinMode(btn_3, INPUT)
pinMode(btn_4, INPUT)
pinMode(btn_5, INPUT)
pinMode(btn_6, INPUT)
pinMode(ctrl_btn, INPUT)
pinMode(cs, OUTPUT)
pinMode(LED, OUTPUT)
digitalWrite(btn_1, HIGH)
digitalWrite(btn_2, HIGH)
digitalWrite(btn_3, HIGH)
digitalWrite(btn_4, HIGH)
digitalWrite(btn_5, HIGH)
digitalWrite(btn_6, HIGH)
digitalWrite(ctrl_btn, HIGH)
lcd.begin(16, 2)
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F(' Electronic'))
lcd.setCursor(0, 1)
lcd.print(F(' Voting Machine'))
delay(2000)
if (!SD.begin(cs))
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('SD Card failed'))
lcd.setCursor(0, 1)
lcd.print('or not present')
while (true)
{
digitalWrite(LED, HIGH)
delay(100)
digitalWrite(LED, LOW)
delay(100)
}
}
if (SD.exists('save.txt'))
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Opening Results'))
lcd.setCursor(0, 1)
lcd.print(F('----------------'))
delay(1500)
DisplayResult()
}
else
{
Party1File = SD.open('Party1.txt', FILE_WRITE)
if (Party1File)
{
Party1File.println('--------Null-------')
Party1File.close()
}
else
{
Error()
}
Party2File = SD.open('Party2.txt', FILE_WRITE)
if (Party2File)
{
Party2File.println('--------Null-------')
Party2File.close()
}
else
{
Error()
}
Party3File = SD.open('Party3.txt', FILE_WRITE)
if (Party3File)
{
Party3File.println('--------Null-------')
Party3File.close()
}
else
{
Error()
}
Party4File = SD.open('Party4.txt', FILE_WRITE)
if (Party4File)
{
Party4File.println('--------Null-------')
Party4File.close()
}
else
{
Error()
}
Party5File = SD.open('Party5.txt', FILE_WRITE)
if (Party5File)
{
Party5File.println('--------Null-------')
Party5File.close()
}
else
{
Error()
}
Party6File = SD.open('Party6.txt', FILE_WRITE)
if (Party6File)
{
Party6File.println('--------Null-------')
Party6File.close()
}
else
{
Error()
}
}
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Machine Status:'))
lcd.setCursor(0, 1)
lcd.print(F('Initialized !!!'))
digitalWrite(LED, HIGH)
delay(2000)
digitalWrite(LED, LOW)
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Machine is ready'))
lcd.setCursor(0, 1)
lcd.print(F('----------------'))
while (!ballot)
{
if (digitalRead(ctrl_btn) == LOW)
{
ballot = true
for (int y = 0 y <3 y++)
{
digitalWrite(LED, HIGH)
delay(100)
digitalWrite(LED, LOW)
delay(100)
}
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Cast Your Vote'))
lcd.setCursor(0, 1)
lcd.print(F('----------------'))
}
}
}
void loop()
{
pinMode(LED, INPUT)
if (digitalRead(LED) == HIGH)
{
save = SD.open('save.txt', FILE_WRITE)
if (save)
{
save.println('Results File')
save.close()
}
else
{
Error()
}
}
if (SD.exists('save.txt'))
{
while (true)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Results Saved'))
lcd.setCursor(0, 1)
lcd.print(F('Successfully.'))
delay(1500)
lcd.setCursor(0, 0)
lcd.print(F('Disconnect the'))
lcd.setCursor(0, 1)
lcd.print(F('Power Supply'))
delay(1500)
}
}
if (digitalRead(btn_1) == LOW)
{
Party_1()
}
if (digitalRead(btn_2) == LOW)
{
Party_2()
}
if (digitalRead(btn_3) == LOW)
{
Party_3()
}
if (digitalRead(btn_4) == LOW)
{
Party_4()
}
if (digitalRead(btn_5) == LOW)
{
Party_5()
}
if (digitalRead(btn_6) == LOW)
{
Party_6()
}
}
void Party_1()
{
ballot = false
SD.remove('Party1.txt')
Party1File = SD.open('Party1.txt', FILE_WRITE)
if (Party1File)
{
Party1_Count = Party1_Count + 1
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('You voted for:'))
lcd.setCursor(0, 1)
lcd.print(Party1)
Party1File.print(Party1_Count)
Party1File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_2()
{
ballot = false
SD.remove('Party2.txt')
Party2File = SD.open('Party2.txt', FILE_WRITE)
if (Party2File)
{
Party2_Count = Party2_Count + 1
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('You voted for:'))
lcd.setCursor(0, 1)
lcd.print(Party2)
Party2File.print(Party2_Count)
Party2File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_3()
{
ballot = false
SD.remove('Party3.txt')
Party3File = SD.open('Party3.txt', FILE_WRITE)
if (Party3File)
{
Party3_Count = Party3_Count + 1
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('You voted for:'))
lcd.setCursor(0, 1)
lcd.print(Party3)
Party3File.print(Party3_Count)
Party3File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_4()
{
ballot = false
SD.remove('Party4.txt')
Party4File = SD.open('Party4.txt', FILE_WRITE)
if (Party4File)
{
Party4_Count = Party4_Count + 1
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('You voted for:'))
lcd.setCursor(0, 1)
lcd.print(Party4)
Party4File.print(Party4_Count)
Party4File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_5()
{
ballot = false
SD.remove('Party5.txt')
Party5File = SD.open('Party5.txt', FILE_WRITE)
if (Party5File)
{
Party5_Count = Party5_Count + 1
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('You voted for:'))
lcd.setCursor(0, 1)
lcd.print(Party5)
Party5File.print(Party5_Count)
Party5File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Party_6()
{
ballot = false
SD.remove('Party6.txt')
Party6File = SD.open('Party6.txt', FILE_WRITE)
if (Party6File)
{
Party6_Count = Party6_Count + 1
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('You voted for:'))
lcd.setCursor(0, 1)
lcd.print(Party6)
Party6File.print(Party6_Count)
Party6File.close()
Tone()
ctrl()
}
else
{
Error()
}
}
void Error()
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Unable to log'))
lcd.setCursor(0, 1)
lcd.print(F('data to SD card'))
for (int x = 0 x <100 x++)
{
digitalWrite(LED, HIGH)
delay(250)
digitalWrite(LED, LOW)
delay(250)
}
}
void Tone()
{
pinMode(LED, OUTPUT)
digitalWrite(LED, HIGH)
delay(1000)
digitalWrite(LED, LOW)
delay(1500)
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F(' Thanks for'))
lcd.setCursor(0, 1)
lcd.print(F(' Voting!!!'))
delay(1500)
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F(' Not Ready'))
lcd.setCursor(0, 1)
lcd.print('----------------')
}
void ctrl()
{
while (!ballot)
{
pinMode(LED, INPUT)
if (digitalRead(LED) == HIGH)
{
save = SD.open('save.txt', FILE_WRITE)
if (save)
{
save.println('Results File')
save.close()
}
else
{
Error()
}
}
if (SD.exists('save.txt'))
{
while (true)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Results Saved'))
lcd.setCursor(0, 1)
lcd.print(F('Successfully.'))
delay(1500)
lcd.setCursor(0, 0)
lcd.print(F('Disconnect the'))
lcd.setCursor(0, 1)
lcd.print(F('Power Supply'))
delay(1500)
}
}
if (digitalRead(ctrl_btn) == LOW)
{
ballot = true
for (int y = 0 y <3 y++)
{
digitalWrite(LED, HIGH)
delay(100)
digitalWrite(LED, LOW)
delay(100)
}
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F('Cast Your Vote'))
lcd.setCursor(0, 1)
lcd.print(F('----------------'))
}
}
}
void DisplayResult()
{
while (true)
{
Party1File = SD.open('party1.txt')
if(Party1File)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(Party1)
while (Party1File.available())
{
lcd.setCursor(A, 1)
lcd.write(Party1File.read())
A = A + 1
}
}
A = 0
delay(2000)
Party1File.close()
Party2File = SD.open('party2.txt')
if(Party2File)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(Party2)
while (Party2File.available())
{
lcd.setCursor(B, 1)
lcd.write(Party2File.read())
B = B + 1
}
}
B = 0
delay(2000)
Party2File.close()
Party3File = SD.open('party3.txt')
if(Party3File)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(Party3)
while (Party3File.available())
{
lcd.setCursor(C, 1)
lcd.write(Party3File.read())
C = C + 1
}
}
C = 0
delay(2000)
Party3File.close()
Party4File = SD.open('party4.txt')
if(Party4File)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(Party4)
while (Party4File.available())
{
lcd.setCursor(D, 1)
lcd.write(Party4File.read())
D = D + 1
}
}
D = 0
delay(2000)
Party4File.close()
Party5File = SD.open('party5.txt')
if(Party5File)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(Party5)
while (Party5File.available())
{
lcd.setCursor(E, 1)
lcd.write(Party5File.read())
E = E + 1
}
}
E = 0
delay(2000)
Party5File.close()
Party6File = SD.open('party6.txt')
if(Party6File)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(Party6)
while (Party6File.available())
{
lcd.setCursor(F, 1)
lcd.write(Party6File.read())
F = F + 1
}
}
F = 0
delay(2000)
Party6File.close()
}
}
//--------Program Developed by R.Girish------//
Come utilizzare questa macchina per il voto elettronico:

• Dopo aver completato la configurazione hardware, caricare il codice con i nomi dei candidati desiderati.
• Accendi la macchina, se tutto va bene emetterà un lungo beep.
• Ora premi il pulsante di controllo e ora può registrare un singolo voto.
• Dopo ogni votazione il pulsante di controllo deve essere premuto una volta.
• Una volta espresso l'ultimo voto, premere il pulsante salva questo salverà i risultati e ti chiederà di scollegare l'alimentazione (in modo da poter visualizzare i risultati in privato).
• Ricollegare l'alimentazione inizierà automaticamente a mostrare i risultati. Se un candidato non ha ottenuto alcun voto, viene visualizzato 'null'.
• Per condurre un'altra elezione, devi formattare la scheda SD / eliminare tutti i file generati da questo EVM.

Si prega di notare che questo EVM necessita di alimentazione ininterrotta, qualsiasi interruzione porterà il conteggio dei voti a zero.

Si prega di scrivere i nomi dei candidati nel codice (massimo 16 lettere):

// ------------------------------------------------ ---- //

String Party1 = 'MODI'

String Party2 = 'TRUMP'

String Party3 = 'PUTIN' // Posiziona qui i nomi dei candidati.

String Party4 = 'Abdul Kalam'

String Party5 = 'Girish'

String Party6 = 'Swagatam'

// ------------------------------------------------ ----- //

Questo conclude il progetto, se hai domande su questo progetto sentiti libero di esprimere nella sezione commenti, potresti ricevere una rapida risposta.