Elektronische Wahlmaschine mit SD-Kartenmodul

In diesem Beitrag werden wir eine Schaltung für eine elektronische Abstimmungsmaschine unter Verwendung des Arduino- und SD-Kartenmoduls erstellen, in der die Wahldaten auf der SD-Karte gespeichert sind.

Durch

AKTUALISIEREN:

Diese Schaltung wurde auf eine verbesserte Version aktualisiert, in der die Ergebnisse über ein angeschlossenes LCD-Display angezeigt werden können. Die Details finden Sie im unteren Bereich des Beitrags

Verwenden von 16x2 LCD-Anzeige

Ein 16 x 2-Display zeigt den Status des Abstimmungsgeräts an. Wenn Sie Ihre Stimme abgeben, wird der Name des Kandidaten zusammen mit der Aktivierung von LED und Summer angezeigt.

Hinweis: Das vorgeschlagene Projekt dient ausschließlich Bildungszwecken und ist nicht für den tatsächlichen Wahlgebrauch bestimmt.

Elektronische Wahlgeräte werden implementiert, um den Wahlprozess zu beschleunigen und das Nutzungspapier zu reduzieren. Diese Gründe reduzieren indirekt die mit Wahlen verbundenen Kosten.

Elektronische Wahlgeräte bieten überlegene Sicherheit vor der herkömmlichen Papierwahlmethode.

Der Transport dieser Wahlurnen ist riskanter als der Transport kompakter Maschinen, bei denen Betrugsfälle bei der Fahrzeugerfassung die Daten in der EVM (Electronic Voting Machine) nicht ändern können, obwohl man das Fahrzeug erfassen kann.

Einige Länder zeigen aufgrund der überlegenen Sicherheit Interesse an in Indien hergestellten EVMs. Länder wie die USA halten bei ihren Wahlen immer noch an der traditionellen Papierwahlmethode fest, da das Risiko, die Wahldaten zu hacken und zu ändern, höher ist.

Was hat den Inder dazu gebracht, EVMs sicherer zu machen? Nun, die USA haben Abstimmungsmaschinen hergestellt, die mit Windows-Betriebssystemen geladen und mit Servern vernetzt sind, um die Stimmenzählung zu vereinfachen. Dies eröffnet Hackern viele Lücken, um die Wahldaten zu ändern.

In Indien hergestellte EVMs sind eigenständige Geräte und nicht mit dem Internet oder Servern verbunden. Zum Zählen der Stimmen werden die Maschinen zum Zählstand gebracht, wo die Ergebnisse deklariert werden und kein Mittelsmann.

Das vorgeschlagene Projekt wurde mit einer ähnlichen Funktionalität wie indische EVMs entworfen, es wurden jedoch viele Änderungen vorgenommen.

Kommen wir nun zu den Konstruktionsdetails des Projekts.

Schaltungslayout:

Die vorgeschlagene EVM-Schaltung kann nur 6 Kandidaten aufnehmen. Eine Steuertaste ist ähnlich der Steuereinheit in realen EVMs vorgesehen. Nachdem eine Person ihre Stimme abgegeben hat, werden die Wahlknöpfe deaktiviert.

Die Stimmzettel werden erst nach Drücken der Steuertaste wieder aktiviert. Der Steuerknopf befindet sich in der Nähe der verantwortlichen Person, die die Wahlkabine kontrolliert.

Nachdem eine Person eine Stimme abgegeben hat, wird sie durch Aktivierung von LED und Summer bestätigt. Die Person kann auch die Abstimmung bestätigen, an die sie im Display abgegeben hat. Sie zeigt einige Sekunden lang den Namen des Kandidaten oder der Partei an. Diese Funktion ist in echten EVMs noch nicht vorhanden.

Schematische Darstellung:

Arduino zeigt Konnektivität an:

Die Schaltung ist in zwei Teile unterteilt, um Verwirrungen beim Duplizieren des Projekts zu vermeiden. Die obige Schaltung beschreibt die Verkabelung zwischen LCD-Display und Arduino. Stellen Sie den variablen Widerstand für einen optimalen Kontrast ein.

Hier ist der Rest der Schaltung bestehend aus 9V Batterie, Schalter, sieben Druckknöpfen, LED, Summer und vor allem SD-Kartenmodul.

Die SD-Karte speichert die Daten sofort nach der Stimmabgabe. Sobald die Wahl beendet ist, wird die SD-Karte in einen Computer eingelegt, um die Stimmenzahl und das Ergebnis anzugeben.

Das vorgeschlagene Design kann bis zu 4.294.967.295 (das sind mehr als 4 Milliarden) Stimmen pro Kandidat und 25.769.803.770 (mehr als 25 Milliarden, was mehr als das Dreifache der gegenwärtigen Weltbevölkerung entspricht) Stimmen pro Maschine aufzeichnen, und immer noch sind mehr als 99,9% der SD-Karte noch leer .

Dies ist weitaus effizienter als echte EVMs, die 3840 Stimmen pro Maschine aufzeichnen können.

Programm:

//--------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------//
……… Das ist ein riesiges Programm.

So bedienen Sie diese EVM-Schaltung:

• Schalten Sie das Gerät ein. Es ertönt ein Piepton, der anzeigt, dass alles in Ordnung ist. Wenn das Gerät nicht in Ordnung ist, piept es schnell und zeigt die Fehlermeldung auf dem LCD an.
• Drücken Sie die Steuertaste, um eine Stimme aufzunehmen.
• Sobald die Abstimmung aufgezeichnet wurde, wird die LED aktiviert und für eine Sekunde piept und der Name des Kandidaten angezeigt, für den Sie einige Sekunden lang abgestimmt haben.
• Um die nächste Abstimmung aufzuzeichnen, muss die Steuertaste erneut gedrückt werden. Jedes Mal, wenn die Steuertaste gedrückt wird, gibt der Summer 3 kurze Pieptöne aus.
• Dies muss fortgesetzt werden, bis der letzte Wähler seine Stimme abgegeben hat. Es ist nicht erforderlich, den Steuerknopf zu drücken, nachdem der letzte Wähler die Abstimmung durchgeführt hat.
• Nach der letzten Abstimmung sollte das Gerät sofort mit dem Aus-Schalter ausgeschaltet und die SD-Karte entfernt werden. Damit werden keine Daten geändert.
• Stecken Sie die SD-Karte in einen Computer und Sie sehen 6 Textdateien wie unten gezeigt:

Beim Öffnen einer Datei werden der Name des Kandidaten und die Anzahl der Stimmen angezeigt, wie unten dargestellt:

Prototyp des Autors:

Abbildung des SD-Kartenmoduls:

Hinweis 1: Bei einer Unterbrechung der Stromversorgung wird die Stimmenzahl auf Null zurückgesetzt.
Hinweis 2: Bitte ändern Sie den Namen des Kandidaten im Programm.
String Party1 = 'MODI'
String Party2 = 'TRUMP'
String Party3 = 'PUTIN' // Platziere die Kandidatennamen hier.
String Party4 = 'Abdul Kalam'
String Party5 = 'Girish'
String Party6 = 'Swagatam'
Hinweis 3: Wenn für eine bestimmte Partei / einen bestimmten Kandidaten keine Stimme abgegeben wird, wird die Textdatei nicht auf der SD-Karte angezeigt.

Aktualisieren des obigen Designs

Diese spezielle aktualisierte Version des Projekts für elektronische Abstimmungsmaschinen wurde von Sumesh Chourasia angefordert, der ein begeisterter Leser dieser Website ist.

Dieses Projekt ist eine Verbesserung gegenüber der oben erläuterten elektronischen Abstimmungsmaschine. Der Hauptnachteil des oben genannten EVM (Electronic Voting Machine) war, dass das Ergebnis nicht auf dem 16 x 2 LCD-Display angezeigt werden konnte, sondern nur auf dem Computer.

In diesem Projekt werden wir den erwähnten Nachteil abschießen und mit dem neu vorgeschlagenen Design können wir das Ergebnis der 6 Kandidaten sofort auf dem LCD-Display anzeigen.

Schwierigkeiten, auf die wir gestoßen sind:

Alle Eingangs- / Ausgangspins (von Arduino) des vorherigen EVM-Projekts wurden vom 16 x 2-Display, dem SD-Kartenmodul, den Wahltasten, der Steuertaste und dem Summer verwendet. Kein Platz mehr zum Anschließen eines neuen Knopfes.

Nach einigen Recherchen haben wir festgestellt, dass alle E / A-Pins jederzeit von Ausgang zu Eingang und umgekehrt geändert werden können.

Nach sorgfältiger Beobachtung haben wir den LED / Summer-Pin als Speicherknopf gewählt. Jetzt ist dieser Pin sowohl als Eingang (Speichertaste) als auch als Ausgang (Summer) programmiert.

Es ist zu beachten, dass der Speicher- / Summer-Pin zu einem beliebigen Zeitpunkt in einem beliebigen Zustand zugewiesen ist, d. H. Ausgang oder Eingang.

Die Rennbahn:

LCD zu Arduino Verbindung:

Schließen Sie einfach gemäß den vorherigen Schaltplänen an und verwenden Sie ein 10K-Potentiometer zum Einstellen des Betrachtungskontrasts. Der Rest der Schaltung ist selbsterklärend.

S1 bis S6 sind Wahlknöpfe, über die die Wähler ihre Wahl treffen. Der Speicher- und Kontrollknopf muss von der Wahlurne ferngehalten werden (unter Kontrolle der zuständigen Wahlkabine).

Neues Programm:
//--------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------//
So bedienen Sie dieses elektronische Wahlgerät:

• Laden Sie nach Abschluss des Hardware-Setups den Code mit den Namen Ihrer gewünschten Kandidaten hoch.
• Schalten Sie die Maschine ein. Wenn alles in Ordnung ist, ertönt ein langer Piepton.
• Drücken Sie jetzt die Steuertaste und jetzt kann eine einzelne Stimme aufgezeichnet werden.
• Nach jeder Abstimmung muss die Steuertaste einmal gedrückt werden.
• Sobald die letzte Stimme abgegeben wurde, klicken Sie auf die Schaltfläche Speichern. Dadurch werden die Ergebnisse gespeichert und Sie werden aufgefordert, die Stromversorgung zu trennen (damit Sie die Ergebnisse privat anzeigen können).
• Schließen Sie die Stromversorgung wieder an. Die Ergebnisse werden automatisch angezeigt. Wenn ein Kandidat keine Stimme erhalten hat, wird 'null' angezeigt.
• Um eine weitere Wahl durchzuführen, müssen Sie die SD-Karte formatieren / alle von diesem EVM generierten Dateien löschen.

Bitte beachten Sie, dass dieses EVM eine unterbrechungsfreie Stromversorgung benötigt. Bei jeder Unterbrechung wird die Stimmenzahl auf Null gesetzt.

Bitte schreiben Sie die Kandidatennamen in den Code (maximal 16 Buchstaben):

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

String Party1 = 'MODI'

String Party2 = 'TRUMP'

String Party3 = 'PUTIN' // Platziere die Kandidatennamen hier.

String Party4 = 'Abdul Kalam'

String Party5 = 'Girish'

String Party6 = 'Swagatam'

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

Damit ist das Projekt abgeschlossen. Wenn Sie Fragen zu diesem Projekt haben, können Sie diese gerne im Kommentarbereich ausdrücken. Möglicherweise erhalten Sie eine schnelle Antwort.