Nous savons dans les bureaux, les centres commerciaux et dans de nombreux autres endroits où seule la personne avec carte d'autorisation est autorisée à entrer dans la salle. Ces systèmes utilisent un système de communication RFID. La RFID est utilisée dans les centres commerciaux pour arrêter le vol car les produits sont étiquetés avec une puce RFID et lorsqu'une personne quitte le bâtiment avec la puce RFID, une alarme est déclenchée automatiquement. L'étiquette RFID est conçue aussi petite qu'une partie du sable. Les systèmes d'authentification RFID sont faciles à concevoir et sont bon marché. Certaines écoles et collèges utilisent de nos jours des systèmes de fréquentation basés sur la RFID.
Dans ce projet, nous allons concevoir une machine à voter qui ne compte que les votes authentifiés. Cela se fait en utilisant des étiquettes RFID (Radio Frequency Identification). Ici, nous allons écrire un programme pour ATMEGA pour permettre uniquement aux détenteurs d'étiquettes RFID autorisés de voter. (Vérifiez également ce projet de machine à voter simple)
Composants requis
Matériel: ATMEGA32, alimentation (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), condensateur 100uF (connecté à travers l'alimentation), bouton (cinq pièces), résistance 10KΩ (cinq pièces), condensateur 100nF (cinq pièces), LED (deux pièces), EM-18 (module lecteur RFID).
Logiciel: Atmel studio 6.1, progisp ou flash magic.
Schéma de circuit et explication
Dans le circuit PORTA d'ATMEGA32 est connecté au port de données de l'écran LCD. Ici, il ne faut pas oublier de désactiver la communication JTAG de PORTC vers ATMEGA en changeant les octets de fusible, si l'on veut utiliser le PORTC comme port de communication normal. Dans l'écran LCD 16x2, il y a 16 broches au total s'il y a une lumière noire, s'il n'y a pas de rétro-éclairage, il y aura 14 broches. On peut alimenter ou laisser les broches du rétroéclairage. Or, dans les 14 broches, il y a 8 broches de données (7-14 ou D0-D7), 2 broches d'alimentation en énergie (1 et 2 ou VSS et VDD ou GND et + 5v), 3 ème broches de la commande de contraste (VEE-contrôle l'épaisseur des caractères doivent être illustré), 3 broches de commande (RS & RW & E)
Dans le circuit, vous pouvez observer que je n'ai pris que deux broches de contrôle, cela donne la flexibilité d'une meilleure compréhension, le bit de contraste et READ / WRITE ne sont pas souvent utilisés afin qu'ils puissent être court-circuités à la masse. Cela met l'écran LCD en mode de contraste et de lecture le plus élevé. Nous avons juste besoin de contrôler les broches ENABLE et RS pour envoyer des caractères et des données en conséquence.
Les connexions effectuées pour l'écran LCD sont indiquées ci-dessous:
PIN1 ou VSS à la terre
Alimentation PIN2 ou VDD ou VCC à + 5v
PIN3 ou VEE à la masse (donne le meilleur contraste pour un débutant)
PIN4 ou RS (sélection de registre) à PD6 de uC
PIN5 ou RW (lecture / écriture) à la terre (met l'écran LCD en mode lecture facilite la communication pour l'utilisateur)
PIN6 ou E (Activer) à PD5 de uC
PIN7 ou D0 à PA0 de uC
PIN8 ou D1 à PA1 de uC
PIN9 ou D2 à PA2 de uC
PIN10 ou D3 à PA3 de uC
PIN11 ou D4 à PA4 de uC
PIN12 ou D5 à PA5 de uC
PIN13 ou D6 à PA6 de uC
PIN14 ou D7 à PA7 de uC
Dans le circuit, vous pouvez voir que nous avons utilisé une communication 8 bits (D0-D7). Cependant, ce n'est pas obligatoire et nous pouvons utiliser une communication 4 bits (D4-D7) mais avec un programme de communication 4 bits devient un peu complexe, j'ai donc préféré la communication 8 bits.
Donc, à partir de la simple observation du tableau ci-dessus, nous connectons 10 broches de l'écran LCD au contrôleur dans lequel 8 broches sont des broches de données et 2 broches pour le contrôle.
Avant d'aller de l'avant, nous devons comprendre la communication série. Le module RFID envoie ici des données au contrôleur en série. Il a un autre mode de communication, mais pour une communication facile, nous choisissons RS232. La broche RS232 du module est connectée à la broche RXD d'ATMEGA.
Les données envoyées par le module RFID sont:
Maintenant, pour l'interface du module RFID, les fonctionnalités suivantes sont requises:
1. La broche RXD (fonction de réception de données) du contrôleur doit être activée.
2. Puisque la communication est série, nous devons savoir chaque fois que les données au revoir sont reçues, afin de pouvoir arrêter le programme jusqu'à ce que l'octet complet soit reçu. Ceci est fait en activant une interruption complète de réception de données.
3. La RFID envoie les données au contrôleur en mode 8 bits. Ainsi, deux caractères seront envoyés au contrôleur à la fois. Ceci est montré dans le bloc de la figure 3
4. A partir de la figure 3, il n'y a pas de bits de parité, un bit d'arrêt dans les données envoyées par le module.
Les fonctionnalités ci-dessus sont définies dans les registres du contrôleur; nous allons en discuter brièvement,
ROUGE (RXEN): Ce bit représente la fonction de réception de données, ce bit doit être mis à 1 pour que les données du module soient reçues par le contrôleur, il active également la broche RXD du contrôleur.
MARRON (RXCIE): Ce bit doit être mis à 1 pour obtenir une interruption après une réception de données réussie. En activant ce bit, nous apprenons à connaître, juste après la réception de données 8 bits.
PINK (URSEL): Ce bit doit être défini avant d'activer d'autres bits dans UCSRC, après avoir défini d'autres bits nécessaires dans UCSRC; URSEL doit être désactivé ou mis à zéro.
JAUNE (UCSZ0, UCSZ1, UCSZ2): Ces trois bits sont utilisés pour sélectionner le nombre de bits de données que nous recevons ou envoyons en une seule fois.
Puisque les données envoyées par le module RFID sont de type 8 bits (FIGURE3), nous devons définir UCSZ0, UCSZ1 sur un et UCSZ2 sur zéro.
ORANGE (UMSEL): ce bit est défini selon que le système communique de manière asynchrone (les deux utilisent une horloge différente) ou de manière synchrone (les deux utilisent la même horloge),
Le module et l'automate utilisant une horloge différente, ce bit doit être mis à zéro ou laissé seul car ils sont tous mis à zéro par défaut.
VERT (UPM1, UPM0): Ces deux bits sont ajustés en fonction de la parité des bits que nous utilisons dans la communication.
Étant donné que le module RFID envoie des données sans parité (FIGURE3), nous avons mis UPM1, UPM0 à zéro ou ils peuvent être laissés seuls car tous les bits de tous les registres sont mis à zéro par défaut.
BLEU (USBS): Ce bit est utilisé pour choisir le nombre de bits d'arrêt que nous utilisons pendant la communication.
Étant donné que le module RFID envoie des données avec un bit d'arrêt (figure3), nous devons simplement laisser le bit USBS seul.
Maintenant, nous devons enfin régler le débit en bauds, à partir de la figure 3, il est clair que le module RFID envoie des données au contrôleur avec un débit en bauds de 9600 bps (bits par seconde).
La vitesse de transmission est définie dans le contrôleur en choisissant l'UBRRH approprié,
La valeur UBRRH est choisie en croisant le débit en bauds et la fréquence du cristal du processeur,
Ainsi, par référence croisée, la valeur UBRR est considérée comme «6», et donc le débit en bauds est défini.
Il y a cinq boutons présents ici, quatre pour incrémenter les votes des candidats et le cinquième pour remettre à zéro les votes des candidats. Les condensateurs présents ici sont destinés à annuler l'effet de rebond des boutons. S'ils sont retirés, le contrôleur peut en compter plus d'un à chaque fois que le bouton est enfoncé.
Les résistances connectées pour les broches servent à limiter le courant, lorsque le bouton est enfoncé pour tirer la broche vers le sol. Chaque fois qu'un bouton est enfoncé, la broche correspondante du contrôleur est abaissée au sol et ainsi le contrôleur reconnaît qu'un certain bouton est enfoncé et que l'action correspondante doit être entreprise, il peut augmenter les votes des candidats ou réinitialiser les votes en fonction du bouton enfoncé.
Lorsque le bouton représentant une personne correspondante est enfoncé, le contrôleur le sélectionne et incrémente le numéro de personne correspondant dans sa mémoire après l'incrémentation, il affiche le score des personnes correspondantes sur l'écran LCD 16x2.
Le fonctionnement de la machine à voter est mieux expliqué étape par étape du code C ci-dessous:
Explication du code
#include // en-tête pour activer le contrôle du flux de données sur les broches
#define F_CPU 1000000 // indiquant la fréquence du cristal du contrôleur connecté
#comprendre
#define E 5 // donnant le nom «enable» à la 5 ème broche de PORTD, car elle est connectée à la broche d'activation de l'écran LCD
#define RS 6 // donnant le nom «registerselection» à la 6 ème broche de PORTD, car elle est connectée à la broche RS de l'écran LCD
void send_a_command (commande char non signée);
void send_a_character (caractère char non signé);
void send_a_string (char * string_of_characters);
int main (void)
{
DDRA = 0xFF; // mettre porta comme broches de sortie
DDRD = 0b11111110;
_delay_ms (50); // donnant un délai de 50ms
DDRB = 0b11110000; // Prenant certaines broches du portB en entrée.
UCSRB - = (1 <
// activation de l'interruption complète de la réception des données, activation de la broche de réception des données
UCSRC - = (1 <
// modification des autres bits en définissant d'abord URSEL, paramètre pour la communication 8 bits
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // réglage de la vitesse de transmission
int16_t VOTEA = 0; // personne1 vote en mémoire
char A; // personne1 vote affichant un caractère sur l'écran LCD
int16_t VOTEB = 0;; // personne2 vote en mémoire
char B; // personne2 vote affichant un caractère sur l'écran LCD
int16_t VOTEC = 0;; // person3 vote en mémoire
char C; // personne3 vote affichant un caractère sur l'écran LCD
int16_t VOTED = 0;; // person4 vote en mémoire
char D; / / person4 votes affichant un caractère sur l'écran LCD
// Ce qui suit contient l'ID des balises, celles-ci doivent être modifiées pour différentes balises, celles-ci doivent être mises à jour pour que le projet fonctionne
// Après avoir vidé le programme dans le contrôleur, il faut prendre les cartes qui doivent être autorisées et obtenir l'ID des tags, ceux-ci sont obtenus en plaçant l'étiquette près du module RFID et l'ID sera affiché à l'écran. Après avoir obtenu les ID, le programme doit être mis à jour en remplaçant les numéros d'identification ci-dessous par de nouveaux numéros d'identification.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Maintenant ci-dessus, nous n'autorisons que cinq cartes, celles-ci peuvent être changées en n'importe quel nombre
Par exemple, considérez que le programme par défaut est vidé dans le contrôleur, récupérez les cartes qui devraient être autorisées les unes après les autres près du module, vous obtiendrez l'ID pour chacune d'elles sous la forme xxxxxxxx (907a4F87)
S'il y a 7 balises que nous avons, alors nous aurons 7 ID de huit bits.
|
// maintenant pour sept cartes ça va comme // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // allouer de la mémoire pour afficher l'ID envoyé par le module int i = 0; vote int = 0; int k = 0; send_a_command (0x01); // Effacer l'écran 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // indiquant à l'écran LCD que nous utilisons le mode commande / données 8 bits _delay_ms (50); send_a_command (0b00001111); // ÉCRAN LCD ON et courser clignotant char MEM; // allouer de la mémoire pour stocker l'ID complet de la balise send_a_string ("RFID NUMBER"); // envoi de la chaîne send_a_command (0x80 + 0x40 + 0); // déplacement du coursier vers la deuxième ligne tandis que (1) { tandis que (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR stocke les données de huit bits reçues et est pris dans un entier. MEM = COUNTA; // les deux premiers caractères sont mis à jour en mémoire itoa (COUNTA, SHOWA, 16); // commande pour mettre le nombre de variable dans l'écran LCD (nombre de variable, dans quel caractère remplacer, quelle base est variable (dix ici car nous comptons le nombre en base10)) send_a_string (SHOWA); // indiquant à l'écran d'afficher le caractère (remplacé par un nombre variable) de la deuxième personne après avoir positionné le coursier sur l'écran LCD tandis que (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // les troisième et quatrième caractères sont mis à jour en mémoire tandis que (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // cinquième et sixième caractères sont mis à jour en mémoire tandis que (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // septième et huit caractères sont mis à jour en mémoire send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
pour (i = 0; i <5; i ++) { si ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// vérification de l'autorisation d'achat en comparant deux caractères à la fois avec les caractères en mémoire PORTB - = (1 <
vote = 1; // si autorisé, définir VOTE } } if (vote == 0) // l'autorisation a échoué si le vote n'est pas défini { UCSRB - = (1 <
} while (vote == 1) // faire cette boucle jusqu'à ce que voté, si autorisé { send_a_command (0x80 + 0); // va à la position zéro sur la ligne1 send_a_string ("VOTE NOW"); // affichage de la chaîne if (bit_is_clear (PINB, 0)) // lorsque le bouton 1 est enfoncé { VOTEA ++; // incrémente de un la mémoire de vote de la première personne vote = 0; // relâcher la boucle while après le vote } if (bit_is_clear (PINB, 1)) // lorsque le bouton 2 est enfoncé { VOTEB ++; // incrémente de un la mémoire de vote de la 2 ème personne vote = 0; } if (bit_is_clear (PINB, 2)) // lorsque le bouton 3 est enfoncé { VOTEC ++; // incrémente de un la mémoire de vote de la 3 ème personne vote = 0; } if (bit_is_clear (PINB, 3)) // lorsque le bouton 4 est enfoncé { VOTED ++; // incrémente de un la mémoire de vote de la 4 ème personne vote = 0; } if (vote == 0) // effacé après le vote reçu { send_a_command (0x80 + 0); // se déplace vers la position zéro de la ligne1 send_a_string ("MERCI POUR VOTRE VOTE"); // affiche la chaîne pour (k = 0; k <10; k ++) { _delay_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // affichage des votes des quatre personnes send_a_string ("A ="); send_a_command (0x80 + 2); itoa (VOTEA, A, 10); send_a_string (A); send_a_command (0x80 + 8); send_a_string ("B ="); send_a_command (0x80 + 10); itoa (VOTEB, B, 10); send_a_string (B); send_a_command (0x80 + 0x40 + 0); send_a_string ("C ="); send_a_command (0x80 + 0x40 + 2); itoa (VOTEC, C, 10); send_a_string (C); send_a_command (0x80 + 0x40 + 8); send_a_string ("D ="); send_a_command (0x80 + 0x40 + 10); itoa (VOTE, D, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); pour (k = 0; k <25; k ++) { _delay_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // passage à la position zéro send_a_string ("RFID NUMBER"); // envoyer une chaîne send_a_command (0x80 + 0x40 + 0); } } void send_a_command (commande char non signée) { PORTA = commande; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (caractère char non signé) { PORTA = caractère; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* string_of_characters> 0) { send_a_character (* string_of_characters ++); } } |