Machine de vote électronique avec module de carte SD

Dans cet article, nous allons construire un circuit pour une machine à voter électronique utilisant Arduino et un module de carte SD où les données d'élection sont stockées sur la carte SD.

Par

METTRE À JOUR:

Ce circuit a été mis à niveau vers une version améliorée dans laquelle les résultats peuvent être visualisés sur un écran LCD attaché, vous pouvez obtenir les détails dans la section inférieure de l'article

Utilisation de l'écran LCD 16x2

Un écran 16 x 2 indique l'état de la machine à voter et lorsque vous votez, le nom du candidat s'affiche avec l'activation de la LED et du buzzer.

Remarque: Le projet proposé est conçu à des fins éducatives uniquement et n'est pas destiné à un usage électoral réel.

Des machines à voter électroniques sont mises en œuvre pour accélérer le processus électoral et réduire l'utilisation du papier et ces raisons réduisent indirectement les dépenses liées aux élections.

Les machines à voter électroniques offrent une sécurité supérieure avant la méthode de vote papier traditionnelle.

Le transport de ces urnes en vrac est plus risqué que de transporter des machines compactes, où les fraudes de capture de véhicule ne peuvent pas modifier les données de l'EVM (Electronic Vote Machine) même si l'on est capable de capturer le véhicule.

Certains pays manifestent de l'intérêt pour les MVE fabriqués en Inde en raison de leur sécurité supérieure. Des pays comme les États-Unis s'en tiennent toujours à la méthode traditionnelle de vote sur papier pour leurs élections en raison du risque plus élevé de piratage et de modification des données électorales.

Alors, qu'est-ce qui a rendu les MVE plus sécurisés par l'Indien? Eh bien, les États-Unis ont fabriqué des machines à voter chargées avec le système d'exploitation Windows et mises en réseau avec des serveurs pour faciliter le décompte des voix. Cela ouvre de nombreuses failles aux pirates pour modifier les données électorales.

Les EVM de fabrication indienne sont des appareils autonomes et non connectés à Internet ou à des serveurs. Pour compter les votes, les machines sont portées à l'isoloir, où les résultats seront déclarés et aucun intermédiaire.

Le projet proposé est conçu avec des fonctionnalités similaires aux EVM indiennes, mais de nombreuses modifications ont été apportées.

Passons maintenant aux détails de construction du projet.

Disposition du circuit:

Le circuit EVM proposé ne peut accueillir que 6 candidats. Un bouton de commande est fourni similaire à l'unité de commande dans les vrais EVM. Une fois qu'une personne a voté, les boutons de vote sont désactivés.

Les boutons de vote ne sont réactivés qu'après avoir appuyé sur le bouton de commande. Le bouton de commande sera placé près du responsable qui contrôle l'isoloir.

Après avoir voté, une personne est reconnue par l'activation de la LED et du buzzer. La personne peut également confirmer le vote à qui il / elle a émis dans l'affichage, il affichera le nom du candidat ou le nom du parti pendant quelques secondes. Cette fonctionnalité n'est pas encore présente dans les vrais EVM.

Diagramme schématique:

Arduino affichant la connectivité:

Le circuit est divisé en deux parties pour éviter les confusions lors de la duplication du projet. Le circuit ci-dessus décrit le câblage entre l'écran LCD et l'arduino. Ajustez la résistance variable pour un contraste optimal.

Voici le reste du circuit composé d'une pile 9V, d'un interrupteur, de sept boutons poussoirs, d'une LED, d'un buzzer et surtout d'un module de carte SD.

La carte SD stockera les données instantanément après le vote. Une fois l'élection terminée, la carte SD est insérée dans un ordinateur pour déclarer le décompte et le résultat des votes.

La conception proposée peut enregistrer jusqu'à 4.294.967.295 (soit plus de 4 milliards) de votes par candidat et 25.769.803.770 (plus de 25 milliards, soit plus de trois fois la population mondiale actuelle) votes par machine et toujours plus de 99,9% La carte SD est toujours vide .

C'est beaucoup plus efficace que les vrais EVM qui peuvent enregistrer 3840 votes par machine.

Programme:

//--------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------//
……… C’est un programme énorme.

Comment faire fonctionner ce circuit EVM:

• Allumez la machine, elle confirmera avec un bip indiquant que tout va bien. Si l'appareil ne fonctionne pas correctement, il émet un bip rapide et affiche le message d'erreur sur l'écran LCD.
• Appuyez sur le bouton de commande, il est maintenant prêt à enregistrer un vote.
• Une fois le vote enregistré, il activera la LED et émettra un bip pendant une seconde et affichera le nom du candidat pour lequel vous avez voté pendant quelques secondes.
• Pour enregistrer le prochain vote, le bouton de commande doit être à nouveau enfoncé. Chaque fois que vous appuyez sur le bouton de commande, le buzzer émet 3 bips courts.
• Cela doit se poursuivre jusqu'à ce que le dernier électeur ait voté. Pas besoin d'appuyer sur le bouton de commande après que le dernier électeur caste le vote.
• Après le dernier vote, la machine doit être immédiatement mise hors tension à l'aide de l'interrupteur d'arrêt et la carte SD doit être retirée. Pour qu'aucune donnée ne soit modifiée.
• Branchez la carte SD sur un ordinateur et vous pouvez voir 6 fichiers texte comme indiqué ci-dessous:

L'ouverture d'un dossier affichera le nom du candidat et le numéro de vote, comme illustré ci-dessous:

Prototype de l'auteur:

Illustration du module de carte SD:

Remarque 1: toute interruption de l'alimentation électrique remettra à zéro le décompte des votes.
Remarque 2: Veuillez changer le nom du candidat dans le programme.
Chaîne Party1 = 'MODI'
String Party2 = 'TRUMP'
String Party3 = 'PUTIN' // Placez les noms des candidats ici.
String Party4 = 'Abdul Kalam'
String Party5 = 'Girish'
String Party6 = 'Swagatam'
Remarque 3: Si aucun vote n'est émis pour un parti / candidat particulier, le fichier texte n'apparaîtra pas sur la carte SD.

Mise à niveau de la conception ci-dessus

Cette version améliorée du projet de machine à voter électronique a été demandée par Sumesh chourasia, qui est un lecteur assidu de ce site Web.

Ce projet est une amélioration par rapport à la machine de vote électronique expliquée ci-dessus. Le principal inconvénient de l'EVM (Electronic Voting Machine) ci-dessus était que le résultat ne pouvait pas être visualisé sur l'écran LCD 16 x 2, mais il ne pouvait être visualisé que sur l'ordinateur.

Dans ce projet, nous allons abattre les inconvénients mentionnés et avec le nouveau design proposé, nous pouvons voir instantanément le résultat des 6 candidats sur un écran LCD.

Difficultés que nous avons rencontrées:

Toutes les broches d'entrée / sortie (d'Arduino) du projet EVM précédent ont été utilisées par l'écran 16 x 2, le module de carte SD, les boutons de vote, le bouton de commande et le buzzer. Plus de place pour connecter un nouveau bouton.

Après quelques recherches, nous avons constaté que toutes les broches d'E / S peuvent être changées en sortie en entrée et vice versa à tout moment.

Après une observation attentive, nous avons choisi la broche LED / buzzer comme bouton d'enregistrement. Maintenant, cette broche est programmée à la fois comme entrée (bouton de sauvegarde) et comme sortie (buzzer).

Notez que la broche de sauvegarde / buzzer est assignée à l'un quelconque des états à un instant, c'est-à-dire sortie ou entrée.

Le circuit:

Connexion LCD à Arduino:

Connectez-vous simplement selon les schémas précédents et utilisez le potentiomètre 10K pour régler le contraste de visualisation.Le reste du circuit est explicite.

S1 à S6 sont des boutons de vote par lesquels les électeurs entrent leur choix. Le bouton de sauvegarde et de contrôle doit être tenu à l'écart du bureau de vote (sous le contrôle de l'isoloir responsable).

Nouveau programme:
//--------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------//
Comment faire fonctionner cette machine à voter électronique:

• Une fois la configuration matérielle terminée, téléchargez le code avec les noms de candidats souhaités.
• Allumez la machine, si tout va bien, elle émettra un long bip.
• Maintenant, appuyez sur le bouton de commande et maintenant il peut enregistrer un seul vote.
• Après chaque vote, le bouton de commande doit être pressé une fois.
• Une fois le dernier vote émis, appuyez sur le bouton Enregistrer, cela enregistrera les résultats et vous invitera à déconnecter l'alimentation électrique (afin que vous puissiez voir les résultats en privé).
• Reconnectez l'alimentation, il commencera automatiquement à afficher les résultats. Si un candidat n’a obtenu aucun vote, il affiche «nul».
• Pour mener une autre élection, vous devez formater la carte SD / supprimer tous les fichiers générés par cet EVM.

Veuillez noter que cet EVM a besoin d'une alimentation ininterrompue, toute interruption réduira le nombre de votes à zéro.

Veuillez inscrire les noms des candidats dans le code (16 lettres maximum):

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

Chaîne Party1 = 'MODI'

String Party2 = 'TRUMP'

String Party3 = 'PUTIN' // Placez les noms des candidats ici.

String Party4 = 'Abdul Kalam'

String Party5 = 'Girish'

String Party6 = 'Swagatam'

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

Cela conclut le projet, si vous avez des questions concernant ce projet, n'hésitez pas à les exprimer dans la section commentaires, vous pouvez recevoir une réponse rapide.