Irodákban, bevásárlóközpontokban és sok más helyen tudjuk, hogy csak az engedélykártyával rendelkező személy léphet be a szobába. Ezek a rendszerek RFID kommunikációs rendszert használnak. Az RFID-t bevásárlóközpontokban használják a lopás megakadályozására, mivel a termékeket RFID-chipkel látják el, és amikor egy személy elhagyja az épületet az RFID-chipdel, automatikusan riasztást ad ki. Az RFID címkét olyan kicsire tervezték, mint a homok. Az RFID-hitelesítési rendszereket könnyű megtervezni és olcsóak. Néhány iskola és főiskola manapság RFID-alapú látogatási rendszereket használ.
Ebben a projektben olyan szavazógépet tervezünk, amely csak hitelesített szavazatokat számít. Ez RFID (rádiófrekvenciás azonosítás) címkék használatával történik. Itt egy olyan programot fogunk írni az ATMEGA számára, amely csak az engedélyezett RFID-címkek birtokosainak szavazását teszi lehetővé. (Ellenőrizze ezt az egyszerű szavazógép-projektet is)
Szükséges alkatrészek
Hardver: ATMEGA32, tápegység (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), 100uF kondenzátor (tápfeszültségre csatlakoztatva), gomb (öt darab), 10KΩ ellenállás (öt darab), 100nF kondenzátor (öt darab), LED (két darab), EM-18 (RFID olvasó modul).
Szoftver: Atmel studio 6.1, progisp vagy flash magic.
Áramkör diagram és magyarázat
Az áramkörben az ATMEGA32 PORTA csatlakozik az LCD adatportjához. Itt kell emlékezni arra, hogy a biztosíték byte-ok megváltoztatásával tiltsa le a JTAG kommunikációt a PORTC-ban ATMEGA-ra, ha normál kommunikációs portként akarja használni a PORTC-t. A 16x2 LCD-képernyőn összesen 16 érintkező van, ha fekete a fény, ha nincs háttérvilágítás, akkor 14 tű lesz. A hátsó lámpa csapjai bekapcsolhatók, vagy elhagyhatók. Most a 14 csapok vannak 8 adatok csapok (7-14 vagy D0-D7), 2 tápegység csapok (1 & 2 vagy VSS & VDD vagy GND & + 5V), 3 rd pin kontraszt vezérlő (VEE-kontrollok milyen vastag a karaktereket kell lennie ábra), 3 vezérlőcsap (RS & RW & E)
Az áramkörben megfigyelhetõ, hogy csak két vezérlõ csapot vettem át, ez rugalmasságot biztosít a jobb megértéshez, a kontrasztbitet és a READ / WRITE-t nem használják gyakran, így testzárlatosak lehetnek. Ez az LCD-t a legnagyobb kontrasztú és olvasási módba helyezi. Csak az ENABLE és RS csapokat kell vezérelnünk, hogy a karaktereket és az adatokat ennek megfelelően küldhessük el.
Az LCD-hez kapcsolódó csatlakozások az alábbiak:
PIN1 vagy VSS a földre
PIN2 vagy VDD vagy VCC + 5v teljesítményig
PIN3 vagy VEE földelés (a legjobb kontrasztot nyújtja a kezdőknek)
PIN4 vagy RS (Register Selection) az uC PD6-jához
PIN5 vagy RW (olvasás / írás) a földre (az LCD-t olvasási módba állítja, megkönnyíti a kommunikációt a felhasználó számára)
PIN6 vagy E (engedélyezés) az uC PD5-ére
PIN7 vagy D0 - PA0 az uC-től
Az uC PIN8 vagy D1 - PA1
Az uC PIN9 vagy D2 - PA2
PIN10 vagy D3 - u3 PA3
Az uC PIN11 vagy D4 és PA4 között
PIN12 vagy D5 - PA5 az uC-től
Az uC PIN13 vagy D6 - PA6
PIN14 vagy D7 - PA7 az uC-től
Az áramkörben látható, hogy 8 bites kommunikációt használtunk (D0-D7). Ez azonban nem kötelező, és használhatunk 4 bites kommunikációt (D4-D7), de a 4 bites kommunikációs program kissé bonyolulttá válik, ezért inkább a 8 bites kommunikációt választottam.
Tehát a fenti táblázat puszta megfigyelésétől kezdve 10 érintkezős LCD-t csatlakoztatunk a vezérlőhöz, amelyben 8 érintkező adat és 2 vezérlő érintkező.
Mielőtt továbblépnénk, meg kell értenünk a soros kommunikációt. Az RFID modul itt soros módon küldi az adatokat a vezérlőnek. Más kommunikációs módja van, de az egyszerű kommunikáció érdekében az RS232-et választjuk. A modul RS232 tűje csatlakozik az ATMEGA RXD tűjéhez.
Az RFID modul által küldött adatok a következők:
Az RFID modul interfészéhez a következő tulajdonságokra van szükség:
1. Engedélyezni kell a vezérlő RXD tűjét (adatfogadási funkcióját).
2. Mivel a kommunikáció soros, tudnunk kell, ha az adat bye beérkezik, hogy a teljes byte beérkezéséig le tudjuk állítani a programot. Ez az adatfogadás teljes megszakításának engedélyezésével történik.
3. Az RFID adatokat küld a vezérlőnek 8 bites módban. Tehát egyszerre két karakter kerül elküldésre a vezérlőnek. Ez a 3. ábra blokkjában látható
4. A 3. ábrán nincsenek paritásbitek, egy stopbit a modul által küldött adatokban.
A fenti jellemzők a vezérlő regiszterekben vannak beállítva; röviden megvitatjuk őket,
VÖRÖS (RXEN): Ez a bit a fogadási adatok funkciót jelöli, ezt a bitet be kell állítani ahhoz, hogy a modul adatait a vezérlő fogadja, és lehetővé teszi a vezérlő RXD tűjét is.
BROWN (RXCIE): Ezt a bitet úgy kell beállítani, hogy sikeres adatvétel után megszakítást kapjon. Ennek a bitnek az engedélyezésével megismerjük, közvetlenül a 8 bites adatok fogadása után.
PINK (URSEL): Ezt a bitet be kell állítani, mielőtt engedélyezné az egyéb biteket az UCSRC-ben, miután az egyéb szükséges biteket beállítja az UCSRC-ben; Az URSEL-t le kell tiltani, vagy nullára kell állítani.
SÁRGA (UCSZ0, UCSZ1, UCSZ2): Ez a három bit arra szolgál, hogy kiválasszuk az egyszerre fogadott vagy küldött adatbitek számát.
Mivel az RFID modul által küldött adatok 8 bites típusúak (3. ÁBRA), az UCSZ0-t, az UCSZ1-et egyre és az UCSZ2-t nullára kell állítanunk.
ORANGE (UMSEL): Ez a bit annak alapján van beállítva, hogy a rendszer aszinkron (mindkét óra más órát használ) vagy szinkron módon (mindkettő ugyanazt az órát használja) kommunikál,
Mivel a modul és a vezérlő különböző órát használ, ezt a bitet nullára kell állítani, vagy egyedül kell hagyni, mivel alapértelmezés szerint mind nullára vannak állítva.
ZÖLD (UPM1, UPM0): Ezt a két bitet a kommunikáció során használt bitparitás alapján állítjuk be.
Mivel az RFID modul paritás nélkül küld adatokat (3. ÁBRA), mind az UPM1-et, mind az UPM0-t nulla értékre állítottuk, vagy békén hagyhatók, mivel a regiszterek összes bitje alapértelmezés szerint nulla.
KÉK (USBS): Ez a bit arra szolgál, hogy kiválassza a stop bitek számát, amelyet a kommunikáció során használunk.
Mivel az RFID modul egy stop bittel küld adatokat (3. ábra), csak magunkra kell hagynunk az USBS bitet.
Most végre be kell állítanunk az adatátviteli sebességet, a 3. ábrából egyértelmű, hogy az RFID modul 9600 bps (bit / másodperc) sebességgel küld adatokat a vezérlőnek.
Az adatátviteli sebességet a vezérlő állítja be a megfelelő UBRRH kiválasztásával,
Az UBRRH értéket az adatátviteli sebesség és a CPU kristályfrekvenciájának keresztreferenciájával választjuk meg,
Tehát kereszthivatkozás alapján az UBRR értéke „6”, és így az átviteli sebességet állítják be.
Öt gomb van itt, négy a jelöltek szavazatainak növelésére, az ötödik pedig a jelöltek szavazatának nullára állítására. Az itt található kondenzátorok a gombok pattogó hatásának semmissé tételére szolgálnak. Ha eltávolítják őket, akkor a vezérlő a gomb minden egyes megnyomásakor többet is számlálhat.
A csapokhoz kapcsolt ellenállások az áram korlátozására szolgálnak, amikor a gombot megnyomják a csap földre húzásához. Amikor egy gombot megnyomnak, a vezérlő megfelelő csapja lehúzódik a földre, és így a vezérlő felismeri, hogy bizonyos gombot megnyomtak, és a megfelelő műveletet el kell végezni, ez növelheti a jelölt szavazatait vagy a szavazatok visszaállítását a megnyomott gombtól függően.
Amikor megnyomja a megfelelő személyt ábrázoló gombot, a vezérlő felveszi és növeli a megfelelő személyszámot a memóriájában a növekedés után, ez megmutatja a megfelelő személyek pontszámát a 16x2 LCD kijelzőn.
A szavazógép működését a legjobban az alább megadott C-kód lépésről lépésre magyarázza:
Kód Magyarázat
#include // header az adatfolyam irányításának engedélyezéséhez a csapok felett
#define F_CPU 1000000 // a vezérlő kristály frekvenciája mellékelve
#include
#define E 5 // név „engedélyezés” megadása a PORTD ötödik tűjéhez, mivel az LCD engedélyező tűhöz csatlakozik
#define RS 6 // adó neve „registerselection” 6 th csapját PORTD, mivel van kötve LCD RS pin
void send_a_command (aláíratlan char parancs);
void send_a_character (aláíratlan karakter);
void send_a_string (char * karakterlánc_ karakterei);
int main (érvénytelen)
{
DDRA = 0xFF; // a porta kimeneti csapokként való elhelyezése
DDRD = 0b11111110;
_delay_ms (50); // 50ms késleltetést ad
DDRB = 0b11110000; // Egyes portB csapok bevitele.
UCSRB - = (1 <
// az adatfogadás teljes megszakításának engedélyezése, az adatfogadás PIN engedélyezése
UCSRC - = (1 <
// egyéb bitek megváltoztatása az URSEL első beállításával, a 8 bites kommunikáció beállításával
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // az adatátviteli sebesség beállítása
int16_t VOTEA = 0; // személy1 szavazat memóriát tárol
char A; // person1 szavazat karakter megjelenítésével az LCD-n
int16_t VOTEB = 0;; // memória tároló szavazat2 személy
karakter B; // személy2 szavazat karakter megjelenítésével az LCD-n
int16_t VOTEC = 0;; // memória tároló személy3 szavazat
karakter C; // személy3 szavazat karakter megjelenítésével az LCD-n
int16_t VOTED = 0;; // memória tároló személy4 szavazat
karakter D; / / fő4 szavazat karakter megjelenítésével az LCD-n
// Az alábbi címkék azonosítóját tartalmazza, ezeket meg kell változtatni a különböző címkékhez. Ezeket frissíteni kell a projekt működéséhez
// A program vezérlőbe való bedobása után el kell venni a hitelesítendő kártyákat, és meg kell szereznie a tag-azonosítót. Ezeket úgy kapjuk meg, hogy a címkét az RFID-modul közelébe helyezzük, és az azonosító megjelenik a képernyőn. Az azonosítók megszerzése után frissíteni kell a programot úgy, hogy az alábbi azonosítószámokat új azonosítószámokkal helyettesíti.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Most fent csak öt kártyát engedélyezünk, ezek tetszőleges számra módosíthatók, Például vegye figyelembe, hogy az alapértelmezett program a vezérlőbe kerül, szerezze be az engedélyezni kívánt kártyákat egymás után a modul közelében, mindegyikhez megkapja az azonosítót xxxxxxxx (907a4F87), Ha 7 címkénk van, akkor 7 nyolc bites azonosítónk lesz.
|
// most hét kártya esetén úgy megy // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)};; // memória allokálása a modul által küldött azonosító megjelenítéséhez int i = 0; int szavazás = 0; int k = 0; send_a_command (0x01); // Képernyő törlése 0x01 = 00000001 késedelem_ms (50); send_a_command (0x38); // elmondja az LCD-nek, hogy 8 bites parancs / adat módot használunk késedelem_ms (50); send_a_command (0b00001111); // LCD KÉPERNYŐ BE és a futár villog char MEM; // memória allokálása a címke teljes azonosítójának tárolásához send_a_string ("RFID-SZÁM"); // karakterlánc küldése send_a_command (0x80 + 0x40 + 0); // futárszolgálat áthelyezése a második sorba míg (1) { míg (! (UCSRA & (1 <
{ } COUNTA = UDR; // Az UDR tárolja a kapott nyolc bites adatot, és egész számba veszi. MEM = COUNTA; // az első két karakter frissül a memóriába itoa (COUNTA, SHOWA, 16); // parancs a változó szám LCD-be helyezéséhez (változó szám, melyik karakterben cseréljük le, melyik alap változó (itt tíz, mivel a base10-ben számoljuk) send_a_string (SHOWA); // a kijelző utasítása, hogy mutassa meg a második személy karakterét (változó számmal helyettesítve), miután a futárt az LCD-re helyezte míg (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // a harmadik és negyedik karakter frissül a memóriába míg (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // az ötödik és a hatodik karakter frissül a memóriába míg (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // hetedik és nyolc karakter frissül a memóriába send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
esetén (i = 0; i <5; i ++) { ha ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) {// A jogosultság ellenőrzése vásárol, ha egyszerre két karaktert hasonlít össze a memóriában lévő karakterekkel PORTB - = (1 <
szavazás = 1; // ha engedélyezett, állítsa be a SZAVAZÁST } } if (szavazás == 0) // az engedélyezés sikertelen, ha a szavazás nincs beállítva { UCSRB - = (1 <
} while (szavazás == 1) // ezt a ciklust a szavazásig végezze, ha engedélyezi { send_a_command (0x80 + 0); // menj a nulla pozícióba az 1. vonalon send_a_string ("SZAVAZZ MOST"); // karakterlánc megjelenítése if (bit_is_clear (PINB, 0)) // amikor az egyik gombot megnyomjuk { VOTEA ++; // eggyel növeli az első személy szavazati memóriáját szavazás = 0; // a ciklus elengedése a szavazás után } if (bit_is_clear (PINB, 1)) // a 2. gomb megnyomásakor { VOTEB ++; // megnövelni a szavazás emlékét 2 nd személy egy szavazat = 0; } if (bit_is_clear (PINB, 2)) // a 3 gomb megnyomásakor { VOTEC ++; // a harmadik személy szavazati memóriáját növeli eggyel szavazat = 0; } if (bit_is_clear (PINB, 3)) // amikor megnyomják a 4 gombot { Szavazott ++; // megnövelni a szavazás memória 4 -én személy szerint egy szavazat = 0; } if (szavazás == 0) // törölve a szavazás beérkezését követően { send_a_command (0x80 + 0); // lépés az 1. sor nulla pozíciójába send_a_string ("KÖSZÖNJÜK A SZAVAT"); // karakterlánc megjelenítése for (k = 0; k <10; k ++) { késedelem_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // mind a négy személy szavazatainak megjelenítése 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 (VOTED, D, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); for (k = 0; k <25; k ++) { késedelem_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // nulla pozícióba lépés send_a_string ("RFID-SZÁM"); // karakterlánc küldése send_a_command (0x80 + 0x40 + 0); } } void send_a_command (aláíratlan karakterparancs) { PORTA = parancs; PORTD & = ~ (1 <
PORTD - = 1 <
késedelem_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (aláíratlan karakter) { PORTA = karakter; PORTD - = 1 <
PORTD - = 1 <
késedelem_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* karakterláncok_0> 0) { send_a_character (* karakter_lánc_figurája ++); } } |