Kapcsolja be az Arduino -t mágneses kártyaolvasóba!: 9 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:44

Szerintem mindenki használt mágneses kártyaolvasót. Mármint ki hord manapság készpénzt? Őket sem nehéz a kezükbe venni, és a kedvenc helyi elektronikai üzletembe tett kirándulás során találtam egy kukát, tele ezekkel a srácokkal. Szóval… természetesen elővettem egyet, és hazavittem, hogy lássam, milyen dolgokat tudok vele csinálni és egy AVR -t.

Ez az oktatóanyag megmutatja, hogyan lehet Magtek mágneses kártyaolvasót csatlakoztatni AVR -hez vagy Arduino/klónhoz, és olvasni az adatokat a kártya első számából. Csatolja be az üléseket; a mágneses kártyaolvasók nagy bitsebességgel rendelkeznek!

1. lépés: A berendezések listája

Íme néhány dolog, amire szüksége van az induláshoz.

• Mágneses kártyaolvasó (az enyém egy Magetk 90 mm-es kétfejű olvasó. $ 5.00)
• AVR, Arduino vagy klón (ATmega328p ~ $ 4.30 a Mouser.com -tól
• forrasztás nélküli kenyeretábla
• valami drót
• talán fejléc, ha tetszik az ilyesmi.
• olvasson valamit a soros porton. A BattleDroids.net AVR terminált használom

Az induláshoz ennyi kell. Attól függően, hogy a magcard olvasót végül megkapja, előfordulhat, hogy módosítania kell ezeket az utasításokat, és minden bizonnyal a kódot, hogy működjön együtt az adott olvasóval. Az általam írt kódnak azonban messzire kell jutnia, remélem.

2. lépés: Önzáró mágneses kártyaolvasók

A mágneses kártyaolvasók "öngyorsítóak", vagyis villogónak nevezett órát biztosítanak, amely ellen a csatlakoztatott mikrokontroller szinkronizálhat. Ez áldás. Ez azt jelenti, hogy nem kell attól tartania, hogy órajelet keres, és a jelet közvetlenül az óraimpulzus középpontjába időzíti, és nem kell zavaróan oszcillálnia az órajel édes pontjába. Ennek akkor van értelme, ha a kártyák ellopására gondol: mindenki más ütemben lapoz, van, aki lassabban, van, aki gyorsabban, mint mások. Az öngyorsítás még édes nagymamámnak is lehetővé teszi a kártya használatát anélkül, hogy eltörte volna a csuklóját. Emlékeztet arra, hogy meg kell változtatnom azt a beállítást, amely meghatározza, hogy mennyi idő teljen el a kattintások között a dupla kattintás regisztrálásához….

Ez a kártyaolvasó adatai 1.0 -ig érvényesek, mielőtt a stroboszkópot a vonalra állítják, így nem kell aggódnia, hogy késlelteti magát a "bitidőbe". Az általam használt kettős fejű olvasó esetében két adatsáv áll rendelkezésre. Ebben az ible -ban az elsődleges szám olvasását fogom megmutatni az induláshoz. Öt kapcsolatot kell létrehoznia (négyet, ha nem bánja, hogy feladja a finomhangolt vezérlést kevesebb I/O port használatához). Nézze meg az alábbi képet. A piros vezeték +5V -ra, míg a fekete vezeték a földre megy. A zöld vezeték /CARD_PRESENT; a sárga vezeték /STROBE, a fehér vezeték pedig a /DATA1. A perjel (/) azt jelenti, hogy az adatok megfordulnak. Az alacsony jel (pl. 0) egyként vagy magasként olvasható. A többi csatlakozó barna a /STROBE2 és narancssárga a /DATA2 számára. Ezeket nem fogjuk használni. Ha szeretné, elfelejtheti a /CARD_PRESENT szolgáltatást. Ez az adatsor körülbelül 17 fejfluxus -elforgatás után lecsökken, jelezve, hogy kártya van jelen (mondjuk véletlen zaj helyett, ami az olvasót hamis adatok küldésére készteti), és arra szolgál, hogy ellenőrizze, hogy a kapott adatok kártyaadatok és nem szemét. Ezt a kapcsolatot kihagyhatja, ha ellenőrzi az adatfolyam kezdő őrszemét. Erről majd később. Mint alább látható, derékszögű férfi fejlécet használtam egy kenyértáblához, és ehhez csatlakoztattam az olvasómat. Csatlakoztattam a /STROBE -t a PIND2 -hez (Arduino digitális 2. tűje), /CARD_PRESENT a PIND3 -hoz (illusztrációként), és /DATA1 a PIND4 -hez. Győződjön meg arról, hogy engedélyezte a húzást ezeken a csapokon, hogy a csapok ne lebegjenek. Az Arduino -t is kicseréltem egy Bare Bones AVR -re, mert tetszik, hogy belefér a kenyértáblába.

3. lépés: A mágneskártya alapjai

A mágneses kártya olvasásához az elsődleges funkciók a következők: 1. Észlelje, hogy mikor csúsztatták el a kártyát. adatok Először is bemutatok néhány mágneskártya -alapot, amelyeket tudnia kell, amikor elkezdi írni saját kódját.

Mágneses kártya szabványok

A mágneskártyákat az ISO szabványosítja a következő dokumentumokban: 7810 A hitelkártya méretű dokumentum fizikai jellemzői 7811-1 Dombornyomás 7811-2 Mágnescsík-alacsony koercitivitás 7811-3 A dombornyomott karakterek elhelyezkedése 7811-4 Az 1. és 2. sáv elhelyezkedése 7811- 5 A 3. pálya helye 7811-6 Mágnescsík - nagy koercitivitás 7813 Pénzügyi tranzakciós kártyák Amint láthatja, a pénzügyi kártyák külön dokumentumban vannak megadva, és gyakran más formátumúak, mint például az Ön élelmiszerboltja vagy nemzetközi hívókártyája. Ezekre a különbségekre programozni kell. Éppen hitelkártya és biztosítási kártya volt nálam, így ezekre a típusokra programoztam (amelyek mindkettő B formátumúak).

Kártya formátumok

A mágneskártyáknak több formátuma van. Az A és a B formátum gyakori, a B a leggyakoribb, amit láttam, és amelyet ez a kód támogat. A C -M formátumokat az ISO fenntartja, azt hiszem, míg az N -től ?? intézményi egyéni használatra vannak fenntartva. 1. sáv Pénzügyi kártyák esetében az első sávot 210 bit / hüvelyk sebességgel rögzítik, és felülről a kártya első 0,110 hüvelyk. Az adatok "kártyaadatok" -ként vannak kódolva, mint 7 bit / karakter. Ez 6 bit a a karakter és egy kicsit a paritás érdekében. ~ 79 alfanumerikus karakter található az 1. sávon. A fizikai sorrend visszafelé irányul. Vagyis az adatok vannak, de hátra vannak írva a kártyára (és ezért a firmware fogja olvasni). a paritás furcsa. A kártya adatformátuma így néz ki:

[SS] [FC] [Elsődleges fiók #] [FS] [Név] [FS] [További adatok] [FS] [ES] [LRC], ahol:

SS Start sentinel FC Formátumkód FS Mezőleválasztó ES End sentinel LRC Longitudinal Redundancy Check karakter Az egyik pálya SS = '%', FC = az egyik formátum (sokszor B lesz), az FS gyakran '', az ES '?' és az LRC karakter általában '<', bár a szabványok nem határozzák meg. Amellett, hogy a kártya vissza van írva, az adatok páratlan paritásbittel rendelkeznek, és 0x20 az ASCII -től. Ezt akkor kezeljük, amikor feldolgozzuk az adatokat. 2. sáv A második sáv 0,110 hüvelyk széles, és a kártya tetejétől kezdődik. A rögzítési sűrűsége 75 bit / hüvelyk. Az adatok karakterenként 5 bitesek, és csak körülbelül 40 numerikus szimbólumból állnak. A kártya adatformátumának ezt a struktúrát kell követnie

[SS] [elsődleges fiók #] [FS] [további adatok | diszkrecionális adatok] [ES] [LRC]

A második sáv SS -je a pontosvessző: ';' az FS pedig '=' Ezzel a szent tudással az övé alatt folytassa a következő lépésekkel, hogy megtekintse a fent vázolt eljárást végrehajtó kódot.

4. lépés: A kártya ellopásának észlelése

1. Észlelje, hogy mikor csúsztatták el a kártyát Hivatalosan, ellenőrizze a /CARD_PRESENT érintkezőt, hogy leesett -e. Szerencsére erre nincs igazán szükség. Az érvényes kártyát később ellenőrizzük. Alternatív megoldásként elolvashatja a stroboszkópot, hogy megtudja, mikor kerültek a szalagok a csapra, azonban ez sok nulla órajelet eredményez. Az olvasó körülbelül 60-70 kezdő nullát küld, hogy tájékoztassa Önt az adatok bemutatásáról. Mindazonáltal a bináris adatok jellegével fogjuk meghatározni, hogy mikor kezdjük el a bitek rögzítését. Az első sáv kezdő jelzője (SS) a százalékjel (%). A bináris értéke 0010 0101, ami azt jelenti, hogy 1010 001-ként lesz tárolva (és olvasva) (ez 7 bites, így a 8. bit nem kerül továbbításra). Most az ügyes olvasó észreveszi, hogy bár az adatok visszafelé vannak, nem egyezik a bináris ASCII értékkel. Ez azért van, mert ez 0x20 -as hatszög. A % szimbólum 0x25, a 0100 0101 pedig 0x05. A kártyaadatokból 0x20 -at vonnak le az értékből. Az, aki ott lóg a magas rágcsálásban, az a páratlan paritás bit. Úgy van odarakva, hogy páratlan számú "1" legyen az értékben. Tehát mivel tudjuk, hogy egy érvényes kártya mindig ezzel a kezdő őrszemmel kezdődik, és mivel a paritásbit 1 -es, akkor amikor észleljük az első HIGH -LOW átmenetet az adattűn, akkor tudjuk, hogy most kezdtük el a indítsa el az őrszemet egy kártyáról. Ez most nem mindig lesz igaz, és egy bolondbiztos terv az lenne, ha a /CARD_PRESENT kártyán ellenőrizné, hogy ez még alacsony -e. Az SS indításának legegyszerűbb módja, ha külső megszakítást hozunk létre a /STROBE leeső szélén. Az adatok 1,0 perccel a leeső él előtt érvényesek, tehát amikor a leeső él mintáit vetted, akkor tudod, hogy elolvashatod a /DATA1 tűt, és érvényes értéket kaphatsz. Íme a kód, amellyel létrehozhatja a külső megszakítást, amely egy leeső peremen vált ki.

voidInitInterrupt (void) {// Setup interrupt BSET (EIMSK, INT0); // külső megszakítási maszk BSET (EICRA, ISC01); // eső él BCLR (EICRA, ISC00); // eső él BSET (SREG, 7); // I-bit az SREG-ben}

A közös.h -ban, amelyet minden programomba belefoglalok, megtalálhatók a BSET és a BCLR definíciói. Tekintse meg ezt a fájlt, ha bármilyen kérdése van a bitek beállításával kapcsolatban. Most, amikor a megszakítás kiváltásra kerül, szeretnénk mintát venni a /DATA1 -ből (az én kódomban CARD_DATA -ként definiálva), és beállítani egy bitet egy általános célú IO regiszterben. Ha a hetedik bitnél tartunk, mentsük le a regisztert karakterként a globális pufferünkben. GPIOR0 regisztert használok, mert gyors hozzáférés. Az álkód valami ilyesmi:

Állítsa le a 16 bites időzítőt Időzítő törlése Ha az ADAT LOW, akkor állítsa be a BIT = 1 értéket a REGISTER-ben. Növekedési index Reset BIT

Ha azt kérdezi magától, hogy miért csökkentés a növekedés helyett, akkor ne feledje, hogy az adatok visszafelé vannak, ezért ahelyett, hogy rögzítené a biteket, amikor azokat az LSB -ről az MSB -re kapjuk, elmentjük őket az MSB -ről az LSB -re, így nem kell megfordítanunk a biteket később az adatok feldolgozásakor. Ha nagyon szeretné, ide is hozzáadhat 0x20 hexadecimális számot, de mivel ezeken a villanásokon kb.

ISR (INT0_vect) {StopTimer (); ClearTimer (); if (! BCHK (PIND, CARD_DATA1)) // inverz alacsony = 1 {BSET (GPIOR0, bit); --bit; bDataPresent = 1; } else if (bDataPresent) {BCLR (GPIOR0, bit); --bit; } if (bit <0) {buff [idx] = (char) GPIOR0; ++ idx; bit = 6; } StartTimer ();} Ha kíváncsi arra, hogy miről szól az időzítési tevékenység, ez a lépés tartalmazza annak meghatározását, hogy a kártya mikor hagyta el az olvasót.

5. lépés: Olvassa el az adatfolyamot

Olvassa el az adatfolyamot

Nos, már megmutattam, hogyan kell olvasni az adatokat, mivel ez része a megszakítási szolgáltatási rutinnak a szélső külső megszakításunkhoz. Alternatív módszer lehet az, ha beállítunk egy zászlót az ISR -ben, és a fő hurokban lekérdezzük a zászlót, és így olvassuk be az adatokat, de úgy gondolom, hogy az általam bemutatott mód tisztább. Légy a saját bírád, és írd meg a sajátodat, de az MCU ezt megengedi. Ennek ellenére menjünk tovább, hogy megtudjuk, hogyan lehet felismerni, amikor a kártya elviszi az Elvist, és elhagyta az épületet.

6. lépés: Az olvasót elhagyó kártya észlelése

A kártya eltűnésének észlelése

Formálisan az egyik mintát vesz a /CARD_PRESENT pin -ből, hogy megnézze, megint MAGAS -e, de nincs szükségünk arra, hogy a steenkin ' /CARD_PRESENT felvegyen egy másik I /O portot. Itt jönnek be ezek az időzítők. Minden alkalommal, amikor a megszakítást hívják, mert a /STROBE leeső élét észleltük, leállítunk egy időzítőt, töröljük az időzítő értékét és elkezdjük az olvasást. Amikor befejeztük az olvasást, újra elindítjuk az időzítőt. Ismételje meg az ad nauseum -ot, vagy amíg az időzítő el nem ér egy bizonyos értéket. Ez azt jelenti, hogy az utolsó megszakítást meghívtuk, és nem érkezett több adat, ezért feltételezzük, hogy ez az, és elkezdjük feldolgozni az összegyűjtött adatokat. Az időzítőknél a TIMER1-et, azaz a 16 bites időzítőt használjuk. 16 MHz -es rezonátort használok külsőleg az AVR -hez. Ha arduino -t használ, akkor valószínűleg Ön is az. Tehát 1024 -es előskálázó értéket választottam, ami azt jelenti, hogy az időzítő minden (16 000, 000 /1024) alkalommal növekszik. Vagyis másodpercenként 15, 625 -ször „ketyeg”. A /CARD_PRESENT HIGH jelzéssel jelzi, hogy a kártya az utolsó adatbit után körülbelül 150 ms -ra hagyta el az olvasót. Ennek tudatában úgy döntöttem, hogy minden 1/4 másodpercben ellenőrzöm. Ez valahogy így nézne ki:

((((F_CPU) / PRESCALER) / 4) Tehát amikor a TCNT1 időzítő számláló eléri a 3900 -at, akkor tudom, hogy körülbelül 300 ms volt, és nyugodtan megállapíthatom, hogy a kártya elhagyta az olvasót. Könnyen

#define PRESCALER 1024#define CHECK_TIME ((F_CPU / PRESCALER) / 4) // 250 ms#define StartTimer () BSET (TCCR1B, CS10), BSET (TCCR1B, CS12) // 1024 prescaler#define StopTimer () BCLR (TCCR1B, CS10), BCLR (TCCR1B, CS12) #define ClearTimer () (TCNT1 = 0) Látta az ISR -ben, hogy az időzítőt elindítják, leállítják és törlik minden megszakításkor. Most a fő ciklusban csak azt ellenőrizzük, hogy az időzítő számláló elérte -e a célértékünket, és ha igen, akkor kezdjük el az adatfeldolgozást

(;;) {if (TCNT1> = CHECK_TIME) {

StopTimer (); ClearTimer (); Adatfeldolgozás(); ReadData (); idx = 0; bit = 6; bDataPresent = 0; memset (& buff, 0, MAX_BUFF_SZ1); }} Most már biztonságos az adatok feldolgozása

kód:

7. lépés: Az adatok feldolgozása

Feldolgozza az adatokat

A feldolgozási szakasz a következőkből áll:

• érvényes SS ellenőrzése
• paritás ellenőrzése
• konvertálás ASCII -re
• érvényes ES ellenőrzése
• LRC ellenőrzése

Itt nem foglalkozom a paritás ellenőrzésével, mivel ezt a bitet csak nullára állítottam. Nem számolom az LRC -t ehhez a kis oktatóanyaghoz. Ez az, amit egy teljesebben megvalósított firmware szeretne tenni. Itt van a kód az adatok feldolgozásához a fenti lépések végrehajtásával (a korábban említett módon). Keresse meg az alábbi képen. Meg van jegyezve és elég magától értetődő. Külön megjegyzés a paritásról és az ASCII -ről: Egyszerűen törlöm a paritásbitet (7. bit… azaz egy 1, amely mögött 6 nulla áll), és a "kártyaadatok" konvertálásához 0x20 értéket kell hozzáadni az értékhez. Nagyjából ennyi.

8. lépés: Az adatok megjelenítése

Jelenítse meg az adatokat

A kijelző egy terminálprogramhoz megy, amelyet kifejezetten egy AVR -hez RS232 vagy USB -n keresztül történő csatlakoztatáshoz írtam. A program neve AVR Terminal. A ReadData () módszer meglehetősen csúnya, és arra buzdítunk, hogy keressen egy tisztább megoldást, mint amit én találtam. Az AVR terminálban van egy funkció is. A kimenet először egy egészségbiztosítási kártya, a második egy VISA kártya. Kattintson a gombra a kép bal felső sarkában, és válassza ki az eredeti vagy nagyméretű képet, hogy jobban lássa.

9. lépés: Kódletöltés és csomagolás

Ebben az utasításban a mágneses kártyaolvasók néhány alapját megvitattam, és mutattam néhány kódot, amelyekkel a helyes irányba indulhat el a mágneskártyákról származó adatok olvasásában. Sokkal több munkát lehet elvégezni, például olvasni és dekódolni a 2. sávot, kiszámítani az LRC -t és kiszámítani a páratlan paritást minden bájton. A teljes forráskód letölthető az alábbiakban. Az AVR Studio 4.17 -ben írták. Remélem, tetszett ez a tanulságos, és mint mindig, minden hozzászólást vagy javaslatot várok. Boldog kódolást és AVR -t!