We weten in kantoren, winkelcentra en op veel andere plaatsen waar alleen de persoon met autorisatiekaart de kamer mag betreden. Deze systemen maken gebruik van een RFID-communicatiesysteem. RFID wordt in winkelcentra gebruikt om diefstal te stoppen, aangezien de producten zijn voorzien van een RFID-chip en wanneer een persoon het gebouw verlaat met de RFID-chip, gaat er automatisch een alarm af. De RFID-tag is zo klein ontworpen als een deel van zand. De RFID-authenticatiesystemen zijn eenvoudig te ontwerpen en goedkoop in prijs. Sommige scholen en hogescholen gebruiken tegenwoordig op RFID gebaseerde aanwezigheidssystemen.
In dit project gaan we een stemmachine ontwerpen die alleen geauthenticeerde stemmen telt. Dit wordt gedaan met behulp van RFID-tags (Radio Frequency Identification). Hier gaan we een programma schrijven voor ATMEGA om alleen geautoriseerde RFID-taghouders te laten stemmen. (Bekijk ook dit eenvoudige stemmachine-project)
Componenten vereist
Hardware: ATMEGA32, voeding (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), 100uF condensator (aangesloten over voeding), knop (vijf stuks), 10KΩ weerstand (vijf stuks), 100nF condensator (vijf stuks), LED (twee stuks), EM-18 (RFID-leesmodule).
Software: Atmel studio 6.1, progisp of flash magie.
Schakelschema en uitleg
In circuit is PORTA van ATMEGA32 verbonden met datapoort van LCD. Hier moet men onthouden om de JTAG-communicatie in PORTC naar ATMEGA uit te schakelen door de zekeringbytes te wijzigen, als men de PORTC als een normale communicatiepoort wil gebruiken. In het 16x2 LCD-scherm zijn er in totaal 16 pinnen als er een zwart licht is, als er geen achtergrondlicht is, zijn er 14 pinnen. Men kan de achterlichtpinnen van stroom voorzien of laten. Nu in de 14 pennen zijn er 8 datapennen (7-14 of D0-D7), 2 voedingspennen (1 & 2 of VSS en VDD en GND en + 5 V), 3 rd pin voor contrastregeling (VEE-bepaalt hoe dik de tekens moet afgebeeld), 3 controlepennen (RS & RW & E)
In het circuit kun je zien dat ik maar twee controlepennen heb genomen, dit geeft de flexibiliteit van een beter begrip, het contrastbit en READ / WRITE worden niet vaak gebruikt, zodat ze kunnen worden kortgesloten naar aarde. Dit plaatst LCD in het hoogste contrast en leesmodus. We hoeven alleen de ENABLE- en RS-pinnen te bedienen om tekens en gegevens dienovereenkomstig te verzenden.
De aansluitingen die zijn gemaakt voor LCD worden hieronder gegeven:
PIN1 of VSS naar aarde
PIN2 of VDD of VCC tot + 5v vermogen
PIN3 of VEE naar aarde (geeft maximaal contrast het beste voor een beginner)
PIN4 of RS (registerselectie) naar PD6 van uC
PIN5 of RW (lezen / schrijven) naar aarde (zet LCD in leesmodus vereenvoudigt de communicatie voor de gebruiker)
PIN6 of E (inschakelen) naar PD5 van uC
PIN7 of D0 tot PA0 van uC
PIN8 of D1 naar PA1 van uC
PIN9 of D2 naar PA2 van uC
PIN10 of D3 naar PA3 van uC
PIN11 of D4 naar PA4 van uC
PIN12 of D5 naar PA5 van uC
PIN13 of D6 naar PA6 van uC
PIN14 of D7 naar PA7 van uC
In het circuit kun je zien dat we 8bit-communicatie hebben gebruikt (D0-D7). Dit is echter niet verplicht en we kunnen 4-bits communicatie gebruiken (D4-D7) maar met 4-bits communicatie wordt het programma een beetje ingewikkeld, dus ik gaf de voorkeur aan 8-bits communicatie.
Dus door alleen de bovenstaande tabel te observeren, verbinden we 10 pinnen van het LCD-scherm met de controller waarin 8 pinnen datapinnen zijn en 2 pinnen voor controle.
Voordat we verder gaan, moeten we de seriële communicatie begrijpen. De RFID-module stuurt hier gegevens in serie naar de controller. Het heeft een andere communicatiemodus, maar voor gemakkelijke communicatie kiezen we RS232. De RS232-pin van de module is verbonden met de RXD-pin van ATMEGA.
De gegevens die door de RFID-module worden verzonden, zijn:
Nu zijn voor de RFID-module-interface de volgende functies vereist:
1. De RXD-pin (gegevensontvangstfunctie) van de controller moet ingeschakeld zijn.
2. Aangezien de communicatie serieel is, moeten we weten wanneer de data bye is ontvangen, zodat we het programma kunnen stoppen totdat de volledige byte is ontvangen. Dit wordt gedaan door een volledige onderbreking van de gegevensontvangst mogelijk te maken.
3. RFID stuurt gegevens naar de controller in 8-bits modus. Er worden dus twee karakters tegelijk naar de controller gestuurd. Dit wordt getoond in blok van figuur3
4. Vanaf figuur3 zijn er geen pariteitsbits, één stopbit in de gegevens die door de module worden verzonden.
De bovenstaande functies zijn ingesteld in de registers van de controller; we gaan ze kort bespreken,
ROOD (RXEN): Deze bit vertegenwoordigt de ontvangstgegevensfunctie, deze bit moet worden ingesteld om de gegevens van de module door de controller te ontvangen, het maakt ook de RXD-pin van de controller mogelijk.
BRUIN (RXCIE): Deze bit moet worden ingesteld om een interrupt te krijgen na succesvolle gegevensontvangst. Door dit bit in te schakelen, leren we het kennen, direct nadat 8 bit data is ontvangen.
PINK (URSEL): Deze bit moet worden ingesteld voordat andere bits in UCSRC worden ingeschakeld, na het instellen van andere benodigde bits in UCSRC; URSEL moet worden uitgeschakeld of op nul worden gezet.
GEEL (UCSZ0, UCSZ1, UCSZ2): deze drie bits worden gebruikt voor het selecteren van het aantal databits dat we in één keer ontvangen of verzenden.
Aangezien de gegevens die door de RFID-module worden verzonden, een 8-bits gegevenstype zijn (FIGURE3), moeten we UCSZ0, UCSZ1 op één en UCSZ2 op nul zetten.
ORANJE (UMSEL): Deze bit wordt ingesteld op basis van of het systeem asynchroon communiceert (beide gebruiken een andere klok) of synchroon (beide gebruiken dezelfde klok),
Aangezien de module en de controller verschillende klokken gebruiken, moet deze bit op nul worden gezet of alleen gelaten worden, aangezien ze allemaal standaard op nul zijn ingesteld.
GROEN (UPM1, UPM0): deze twee bits worden aangepast op basis van bitpariteit die we in communicatie gebruiken.
Omdat de RFID-module gegevens zonder pariteit verstuurt (FIGURE3), hebben we zowel UPM1 als UPM0 op nul gezet of ze kunnen met rust worden gelaten, aangezien alle bits in alle registers standaard op nul zijn ingesteld.
BLAUW (USBS): Deze bit wordt gebruikt om het aantal stopbits te kiezen dat we gebruiken tijdens communicatie.
Omdat de RFID-module gegevens verzendt met één stopbit (figuur3), hoeven we de USBS-bit alleen te laten.
Nu moeten we eindelijk de baudrate instellen, uit figuur 3 is het duidelijk dat de RFID-module gegevens naar de controller stuurt met een baudrate van 9600bps (bits per seconde).
De baudrate wordt ingesteld in de controller door de juiste UBRRH te kiezen,
De UBRRH-waarde wordt gekozen door de baudrate en de CPU-kristalfrequentie te wijzigen,
Dus door middel van kruisverwijzing wordt de UBRR-waarde gezien als '6', en dus wordt de baudrate ingesteld.
Er zijn hier vijf knoppen aanwezig, vier voor het verhogen van de stemmen van kandidaten en de vijfde voor het resetten van de stemmen van de kandidaten naar nul. De condensatoren die hier aanwezig zijn, dienen om het stuiterende effect van knoppen teniet te doen. Als ze worden verwijderd, telt de controller mogelijk meer dan één keer elke keer dat de knop wordt ingedrukt.
De weerstanden die voor pinnen zijn aangesloten, zijn bedoeld om de stroom te beperken, wanneer de knop wordt ingedrukt om de pin naar de grond te trekken. Telkens wanneer een knop wordt ingedrukt, wordt de corresponderende pin van de controller naar de grond getrokken en dus herkent de controller dat een bepaalde knop wordt ingedrukt en de bijbehorende actie die moet worden ondernomen, het kan het verhogen van de kandidaatstemmen of het resetten van stemmen zijn, afhankelijk van de ingedrukte knop.
Wanneer de knop die een corresponderende persoon vertegenwoordigt, wordt ingedrukt, kiest de controller deze en verhoogt het corresponderende persoonsnummer in zijn geheugen. Na verhoging toont het de corresponderende persoonsscore op het 16x2 LCD-scherm.
De werking van de stemmachine wordt het beste uitgelegd in stap voor stap van de onderstaande C-code:
Code Uitleg
#include // header om gegevensstroomcontrole over pinnen in te schakelen
#define F_CPU 1000000 // vertellen controller kristalfrequentie aangesloten
# omvatten
#define E 5 // het geven van de naam “enable” om 5 th pin van PORTD, want het is aangesloten op LCD in te schakelen pin
#define RS 6 // het geven van de naam “registerselection” tot 6 th pin van PORTD, omdat is aangesloten op LCD RS pin
void send_a_command (niet-ondertekende tekenopdracht);
void send_a_character (teken zonder teken);
ongeldig send_a_string (char * string_of_characters);
int main (ongeldig)
{
DDRA = 0xFF; // porta als output pinnen zetten
DDRD = 0b11111110;
_delay_ms (50); // geeft een vertraging van 50 ms
DDRB = 0b11110000; // Enkele poortB-pinnen als invoer gebruiken.
UCSRB - = (1 <
// inschakelen van volledige onderbreking van gegevensontvangst, waardoor pin voor gegevensontvangst mogelijk is
UCSRC - = (1 <
// andere bits wijzigen door eerst URSEL in te stellen, instelling voor 8-bits communicatie
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // instellen van de baudrate
int16_t VOTEA = 0; // person1 stemmen geheugen opslaan
char A; // person1 stemmen met karakter op LCD
int16_t VOTEB = 0;; // person2 stemmen geheugen opslaan
char B; // person2 stemmen met karakter op LCD
int16_t VOTEC = 0;; // person3 stemmen geheugen opslaan
char C; // person3 stemmen met karakter op LCD
int16_t GESTEMD = 0;; // person4 stemmen geheugen opslaan
char D; / / person4 stemmen met karakter op LCD
// Het volgende bevat ID van tags, deze moeten worden gewijzigd voor verschillende tags. Deze moeten worden bijgewerkt om het project te laten werken
// Na het dumpen van het programma in de controller moet men de kaarten nemen die geautoriseerd moeten zijn en de tag-ID verkrijgen, deze worden verkregen door de tag naast de RFID-module te plaatsen en de ID wordt op het scherm getoond. Nadat u de ID's hebt ontvangen, moet het programma worden bijgewerkt door de onderstaande ID-nummers te vervangen door nieuwe ID-nummers.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Nu hierboven autoriseren we slechts vijf kaarten, deze kunnen in elk nummer worden gewijzigd, Overweeg bijvoorbeeld dat het standaardprogramma in de controller wordt gedumpt, plaats de kaarten die moeten worden geautoriseerd achter elkaar in de buurt van de module, u krijgt de ID voor elk als xxxxxxxx (907a4F87), Als we 7 tags hebben, hebben we 7 8 bit ID's.
|
// nu voor zeven kaarten gaat het als // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // geheugen toewijzen voor het tonen van de ID verzonden door module int i = 0; int stem = 0; int k = 0; send_a_command (0x01); // Scherm wissen 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // LCD vertellen dat we de 8bit commando / data-modus gebruiken _delay_ms (50); send_a_command (0b00001111); // LCD-SCHERM AAN en harder knipperen char MEM; // geheugen toewijzen om de volledige ID van de tag op te slaan send_a_string ("RFID NUMBER"); // verzendende string send_a_command (0x80 + 0x40 + 0); // courser verplaatsen naar tweede regel terwijl (1) { terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR slaat de ontvangen acht bits gegevens op en wordt in een geheel getal omgezet. MEM = COUNTA; // De eerste twee tekens worden in het geheugen bijgewerkt itoa (COUNTA, SHOWA, 16); // commando voor het plaatsen van variabel nummer in LCD (variabel nummer, in welk teken te vervangen, welke basis is variabel (tien hier omdat we het aantal tellen in basis10)) send_a_string (SHOWA); // het display vertellen om het karakter (vervangen door een variabel nummer) van de tweede persoon weer te geven na het positioneren van de grover op het LCD-scherm terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // derde en vierde tekens worden in het geheugen bijgewerkt terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // vijfde en zesde lettertekens worden in het geheugen bijgewerkt terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // zevende en acht tekens worden in het geheugen bijgewerkt send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
voor (i = 0; i <5; i ++) { if ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// controleren op autorisatie kopen door twee karakters tegelijk te vergelijken met de karakters in het geheugen PORTB - = (1 <
stem = 1; // indien geautoriseerd stel STEM in } } if (vote == 0) // autorisatie mislukt als de stemming niet is ingesteld { UCSRB - = (1 <
} while (vote == 1) // doe deze lus tot er gestemd wordt, indien geautoriseerd { send_a_command (0x80 + 0); // ga naar positie nul op regel1 send_a_string ("STEM NU"); // tekenreeks weergeven if (bit_is_clear (PINB, 0)) // wanneer knop één wordt ingedrukt { VOTEA ++; // verhoog het stemgeheugen van de eerste persoon met één stem = 0; // de while-lus laten gaan na het stemmen } if (bit_is_clear (PINB, 1)) // wanneer knop 2 wordt ingedrukt { VOTEB ++; // verhoog het stemgeheugen van de 2 e persoon met één stem = 0; } if (bit_is_clear (PINB, 2)) // wanneer knop 3 wordt ingedrukt { VOTEC ++; // verhoog het stemgeheugen van de derde persoon met één stem = 0; } if (bit_is_clear (PINB, 3)) // wanneer knop 4 wordt ingedrukt { GESTEMD ++; // verhogen de stemming geheugen van 4 e persoon die door een stem = 0; } if (stem == 0) // gewist na ontvangen stem { send_a_command (0x80 + 0); // ga naar positie nul van line1 send_a_string ("BEDANKT VOOR STEM"); // display string voor (k = 0; k <10; k ++) { _delay_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // tonen van stemmen van alle vier de personen 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 (STEM, 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 (STEMMEN, D, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); voor (k = 0; k <25; k ++) { _delay_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // naar de nulpositie gaan send_a_string ("RFID NUMBER"); // stuur een string send_a_command (0x80 + 0x40 + 0); } } ongeldig send_a_command (niet-ondertekende tekenopdracht) { PORTA = commando; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (teken zonder teken) { PORTA = teken; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* tekenreeks_tekens> 0) { send_a_character (* string_of_characters ++); } } |