Vi vet i kontor, köpcentra och på många andra platser där endast den som har behörighetskort får komma in i rummet. Dessa system använder RFID-kommunikationssystem. RFID används i köpcentra för att stoppa stöld då produkterna är märkta med RFID-chip och när en person lämnar byggnaden med RFID-chipet larmas automatiskt. RFID-taggen är utformad så liten som en del av sand. RFID-autentiseringssystemen är enkla att utforma och kostar billigt. Vissa skolor och högskolor använder numera RFID-baserade närvarosystem.
I det här projektet ska vi utforma en röstmaskin som bara räknar autentiserade röster. Detta görs med hjälp av RFID-taggar (Radio Frequency Identification). Här ska vi skriva ett program för ATMEGA för att endast tillåta innehavare av RFID-taggar att rösta. (Kontrollera även detta enkla röstmaskinprojekt)
Komponenter krävs
Hårdvara: ATMEGA32, strömförsörjning (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), 100uF kondensator (ansluten över strömförsörjning), knapp (fem delar), 10KΩ motstånd (fem delar), 100nF kondensator (fem delar), LED (två delar), EM-18 (RFID-läsarmodul).
Programvara: Atmel studio 6.1, progisp eller flash magi.
Kretsschema och förklaring
I kretsen är PORTA på ATMEGA32 ansluten till dataporten på LCD-skärmen. Här bör man komma ihåg att inaktivera JTAG-kommunikationen i PORTC till ATMEGA genom att byta säkringsbyte, om man vill använda PORTC som en normal kommunikationsport. I 16x2 LCD finns det totalt 16 stift om det finns ett svart ljus, om det inte finns något bakgrundsbelysning kommer det att finnas 14 stift. Man kan driva eller lämna bakljuset. Nu i de 14 stiften finns 8 datastift (7-14 eller D0-D7), 2 effektmatningsstiften (1 & 2 eller VSS & VDD eller GND & + 5v), 3 : e stift för kontrastreglering (VEE-styr hur tjock tecknen bör vara visas), 3 kontrollstift (RS & RW & E)
I kretsen kan du observera att jag bara har tagit två kontrollstift, detta ger flexibiliteten för bättre förståelse, kontrastbiten och LÄS / SKRIV inte ofta så att de kan kortslutas till marken. Detta sätter LCD i högsta kontrast och läsläge. Vi behöver bara kontrollera ENABLE- och RS-stift för att skicka tecken och data i enlighet därmed.
De anslutningar som görs för LCD ges nedan:
PIN1 eller VSS till jord
PIN2 eller VDD eller VCC till + 5v ström
PIN3 eller VEE till marken (ger maximal kontrast bäst för en nybörjare)
PIN4 eller RS (Registrera val) till PD6 i uC
PIN5 eller RW (läs / skriv) till marken (sätter LCD i läsläge underlättar kommunikationen för användaren)
PIN6 eller E (Aktivera) till PD5 för uC
PIN7 eller D0 till PA0 för uC
PIN8 eller D1 till PA1 för uC
PIN9 eller D2 till PA2 för uC
PIN10 eller D3 till PA3 för uC
PIN11 eller D4 till PA4 för uC
PIN12 eller D5 till PA5 för uC
PIN13 eller D6 till PA6 för uC
PIN14 eller D7 till PA7 för uC
I kretsen kan du se att vi har använt 8-bitars kommunikation (D0-D7). Detta är dock inte obligatoriskt och vi kan använda 4-bitars kommunikation (D4-D7) men med 4-bitars kommunikation blir programmet lite komplext, så jag föredrog 8-bitars kommunikation.
Så från enbart observationen av ovanstående tabell ansluter vi 10 stift LCD till styrenheten där 8 stift är datapinnar och 2 stift för kontroll.
Innan vi går vidare måste vi förstå seriekommunikationen. RFID-modulen skickar här data till styrenheten i serie. Den har ett annat kommunikationssätt men för enkel kommunikation väljer vi RS232. RS232-stiftet på modulen är ansluten till RXD-stiftet i ATMEGA.
Data som skickas av RFID-modulen går som:
För RFID-modulgränssnittet krävs nu följande funktioner:
1. Styrenhetens RXD-stift (datamottagningsfunktion) måste vara aktiverad.
2. Eftersom kommunikationen är seriell måste vi veta när data bye tas emot, så att vi kan stoppa programmet tills fullständig byte tas emot. Detta görs genom att möjliggöra en fullständig avbrott för datamottagning.
3. RFID skickar data till styrenheten i 8bit-läge. Så två tecken kommer att skickas till styrenheten åt gången. Detta visas i figur 3
4. Från figur 3 finns inga paritetsbitar, en stoppbit i data som skickas av modulen.
Ovanstående funktioner ställs in i registerregistret; vi ska diskutera dem kort,
RÖD (RXEN): Denna bit representerar funktionen för mottagningsdata, den här biten måste ställas in för att data från modulen ska tas emot av styrenheten, det möjliggör också RXD-stift av styrenheten.
BRUN (RXCIE): Denna bit måste ställas in för att få ett avbrott efter lyckad datamottagning. Genom att aktivera den här biten lär vi oss, direkt efter att 8-bitars data har mottagits.
PINK (URSEL): Denna bit måste ställas in innan du aktiverar andra bitar i UCSRC, efter att du har ställt in andra nödvändiga bitar i UCSRC; URSEL måste inaktiveras eller sättas till noll.
GUL (UCSZ0, UCSZ1, UCSZ2): Dessa tre bitar används för att välja antalet databitar vi tar emot eller skickar på en gång.
Eftersom data som skickas av RFID-modulen är 8-bitars datatyp (FIGUR 3) måste vi ställa UCSZ0, UCSZ1 till en och UCSZ2 till noll.
ORANGE (UMSEL): Denna bit ställs in baserat på om systemet kommunicerar asynkront (båda använder olika klockor) eller synkront (båda använder samma klocka),
Eftersom modul och styrenhet använder olika klockor måste denna bit ställas till noll eller lämnas ensam eftersom de alla är inställda på noll som standard.
GRÖN (UPM1, UPM0): Dessa två bitar justeras baserat på bitparitet som vi använder i kommunikationen.
Eftersom RFID-modulen skickar data utan paritet (FIGUR3) har vi satt både UPM1, UPM0 till noll eller så kan de lämnas ensamma eftersom alla bitar i alla register är nollställda som standard.
BLÅ (USBS): Denna bit används för att välja antalet stoppbitar vi använder under kommunikationen.
Eftersom RFID-modulen skickar data med en stoppbit (figur 3) måste vi bara lämna USBS-biten i fred.
Nu äntligen måste vi ställa in överföringshastigheten, från figur 3 är det tydligt att RFID-modulen skickar data till styrenheten med en överföringshastighet på 9600 bps (bitar per sekund).
Överföringshastigheten ställs in i styrenheten genom att välja lämplig UBRRH,
UBRRH-värdet väljs genom korshänvisande baudhastighet och CPU-kristallfrekvens,
Så genom korsreferens ses UBRR-värdet som '6', och så ställs baudhastigheten in.
Det finns fem knappar här, fyra för att öka kandidaternas röster och femte för att återställa kandidaternas röster till noll. Kondensatorerna som finns här är till för att upphäva knapparnas studsande effekt. Om de tas bort kan styrenheten räkna mer än en varje gång du trycker på knappen.
Motstånden som är anslutna för stift är för att begränsa strömmen när du trycker på knappen för att dra ner stiften till marken. Närhelst en knapp trycks ned, dras motsvarande stift av styrenhet ner till marken och därmed känner styrenheten igen att viss knapp trycks in och motsvarande åtgärder som ska vidtas, kan det öka inkandidatrösterna eller återställa rösterna beroende på vilken knapp som trycks ned.
När du trycker på knappen som representerar en motsvarande person, väljer styrenheten den och ökar motsvarande personnummer i sitt minne efter inkrementet, det visar motsvarande personers poäng på 16x2 LCD-skärmen.
Röstmaskinens funktion förklaras bäst steg för steg av C-koden som ges nedan:
Kodförklaring
#include // header för att aktivera dataflödeskontroll över stift
#define F_CPU 1000000 // berättar styrenhetens kristallfrekvens
#omfatta
#define E 5 // ger namnet "aktivera" till 5: e stift PORTD, eftersom den är ansluten till LCD-stift
#define RS 6 // ger namnet "registerselection" till 6: e stift PORTD, eftersom den är ansluten till LCD RS-stift
ogiltig send_a_command (osignerad char kommando);
ogiltig send_a_character (osignerad char karaktär);
ogiltig send_a_string (char * string_of_characters);
int main (void)
{
DDRA = 0xFF; // sätta porta som utgångsstift
DDRD = 0b11111110;
_delay_ms (50); // ger fördröjning på 50 ms
DDRB = 0b11110000; // Tar några portB-stift som ingång.
UCSRB - = (1 <
// möjliggör datamottagning komplett avbrott, möjliggör datamottagningsstift
UCSRC - = (1 <
// ändra andra bitar genom att först ställa in URSEL, ställa in för 8-bitars kommunikation
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // ställer in överföringshastigheten
int16_t VOTEA = 0; // person1 röster som lagrar minne
char A; // person1 röster som visar tecken på LCD
int16_t RÖSTA = 0;; // person2 röster som lagrar minne
tecken B; // person2 röster som visar tecken på LCD
int16_t VOTEC = 0;; // person3 röster som lagrar minne
char C; // person3 röster som visar tecken på LCD
int16_t RÖSTAD = 0;; // person4 röster som lagrar minne
char D; / / person4 röster som visar tecken på LCD
// Följande innehåller ID för taggar, dessa måste ändras för olika taggar, Dessa måste uppdateras för att projektet ska fungera
// Efter att programmet har dumpats i styrenheten måste man ta de kort som måste vara auktoriserade och få taggen ID, dessa erhålls genom att placera taggen nära RFID-modulen och ID kommer att visas på skärmen. Efter att ha fått ID: n måste programmet uppdateras genom att ersätta nedanstående ID-nummer med nya ID-nummer.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Nu ovan ovan godkänner vi bara fem kort, dessa kan ändras till valfritt nummer, Tänk till exempel på att standardprogrammet dumpas i styrenheten, få de kort som ska vara auktoriserade placera varandra nära modul, du får ID för var och en som xxxxxxxx (907a4F87)
Om det finns 7 taggar vi har, kommer vi att ha 7 åtta bitars ID.
|
// nu för sju kort går det som // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)}, // tilldelning av minne för att visa ID skickat med modul int i = 0; int-omröstning = 0; int k = 0; send_a_command (0x01); // Rensa skärm 0x01 = 00000001 _fördröjning_ms (50); send_a_command (0x38); // säger till lcd att vi använder 8bit kommando / dataläge _fördröjning_ms (50); send_a_command (0b00001111); // LCD SKÄRM PÅ och courser blinkar char MEM; // tilldela minne för att lagra komplett ID för taggen send_a_string ("RFID NUMBER"); // skickande sträng send_a_command (0x80 + 0x40 + 0); // flytta courser till andra raden medan (1) { medan (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR lagrar mottagen åtta bitars data och tas till ett heltal. MEM = COUNTA; // de första två tecknen uppdateras till minnet itoa (COUNTA, SHOWA, 16); // kommando för att sätta variabelt nummer i LCD (variabelt nummer, i vilket tecken som ska ersättas, vilken bas är variabel (tio här när vi räknar nummer i base10)) send_a_string (SHOWA); // ber displayen att visa karaktär (ersatt med variabelt nummer) för den andra personen efter att ha placerat kursledaren på LCD-skärmen medan (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // tredje och fjärde tecknet uppdateras till minnet medan (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // femte och sjätte tecken uppdateras till minnet medan (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // sjunde och åtta tecken uppdateras till minnet send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
för (i = 0; i <5; i ++) { om ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// kontroll av auktoriseringsköp som jämför två tecken i taget med tecknen i minnet PORTB - = (1 <
rösta = 1; // om godkänd ställa in RÖSTA } } om (omröstning == 0) // behörighet misslyckades om omröstning inte är inställd { UCSRB - = (1 <
} medan (omröstning == 1) // gör den här slingan tills den röstas, om den är godkänd { send_a_command (0x80 + 0); // gå till position noll på rad 1 send_a_string ("RÖST NU"); // visar sträng om (bit_is_clear (PINB, 0)) // när knapp en trycks ned { VOTEA ++; // öka röstminnet för första person med en vote = 0; // släppa medan loop går efter omröstning } om (bit_is_clear (PINB, 1)) // när knapp 2 trycks in { VOTEB ++; // öka röstminnet för den andra personen med en rösta = 0; } om (bit_is_clear (PINB, 2)) // när knapp 3 trycks in { Votec ++; // öka omröstningen minne 3 : e personen genom ett rösta = 0; } om (bit_is_clear (PINB, 3)) // när knapp 4 trycks in { RÖSTE ++; // öka röstminnet för 4: e personen med en rösta = 0; } om (omröstning == 0) // rensas efter mottagen röst { send_a_command (0x80 + 0); // flytta till position noll på rad 1 send_a_string ("TACK FÖR RÖST"); // visa sträng för (k = 0; k <10; k ++) { _fördröja_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // visar röster för alla fyra personer 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 (RÖSTAD, D, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); för (k = 0; k <25; k ++) { _fördröja_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // flyttar till nollposition send_a_string ("RFID NUMBER"); // skicka en sträng send_a_command (0x80 + 0x40 + 0); } } ogiltigt send_a_command (osignerat char-kommando) { PORTA = kommando; PORTD & = ~ (1 <
PORTD - = 1 <
_fördröjning_ms (50); PORTD & = ~ 1 <
PORTA = 0; } ogiltig send_a_character (osignerad karaktär) { PORTA = karaktär; PORTD - = 1 <
PORTD - = 1 <
_fördröjning_ms (50); PORTD & = ~ 1 <
PORTA = 0; } ogiltig send_a_string (char * string_of_characters) { medan (* string_of_characters> 0) { send_a_character (* string_of_characters ++); } } |