Gawing Ang iyong Arduino Sa isang Reader ng Magnetic Card !: 9 Mga Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:16

Ang bawat isa ay gumamit ng isang magnetikong card reader, naniniwala ako. Ibig kong sabihin, sino ang nagdadala ng salapi sa mga araw na ito? Hindi sila mahirap na makuha ang iyong mga kamay, alinman, at sa isang paglalakbay sa aking paboritong lokal na tindahan ng electronics, natagpuan ko ang isang basurahan na puno ng mga taong ito. Kaya….syempre, pumili ako ng isa at dinala ito sa bahay upang makita kung anong uri ng bagay ang magagawa ko dito at isang AVR.

Ituturo sa iyo ang itinuturo na ito kung paano ikonekta ang isang Magtek magnetic card reader sa isang AVR o Arduino / clone at basahin ang data mula sa unang track ng card. I-buckle ang iyong mga upuan; ang mga mambabasa ng magnetikong card ay may mataas na rate ng bit!

Hakbang 1: Ang Listahan ng Kagamitan

Narito ang ilang mga bagay na kakailanganin mo upang makapagsimula.

• Magnetic card reader (Ang akin ay isang Magetk 90mm dual-head reader. $ 5.00)
• AVR, Arduino, o clone (ATmega328p ~ $ 4.30 mula sa Mouser.com
• solderless breadboard
• ilang kawad
• marahil isang header kung gusto mo ang bagay na iyon.
• isang bagay na basahin ang iyong serial port. Gumagamit ako ng AVR Terminal mula sa BattleDroids.net

Iyon lang ang dapat mong kailanganin upang makapagsimula. Nakasalalay sa magcard reader na natapos mong makuha, maaaring kailangan mong baguhin ang mga tagubiling ito, at tiyak na ang code, upang gumana sa iyong tukoy na mambabasa. Gayunpaman, ang code na isinulat ko ay dapat na makapagpalayo sa iyo, sana.

Hakbang 2: Mga Mambabasa ng Magnetic Card na self-clocking

Ang mga mambabasa ng magnetikong card ay "self-clocking," nangangahulugang nagbibigay sila ng isang orasan na tinatawag na isang strobo, laban dito maaaring mai-sync ang nakakonektang microcontroller. Ito ay isang biyaya. Nangangahulugan ito na hindi mo kailangang mag-alala tungkol sa paghahanap para sa isang signal ng orasan at itakda ang signal upang direktang nakasentro sa pulso ng orasan, at walang nakakagambalang oscillating sa matamis na lugar ng signal ng orasan. Ito ay may katuturan kapag iniisip mo ang tungkol sa mga swipe ng card: lahat ay nag-swipe sa ibang bilis, ang ilan ay mas mabagal, ang ilan ay mas mabilis kaysa sa iba. Pinahihintulutan ng self-clocking kahit na ang aking matamis na lola ay may kakayahang gamitin ang kanyang card nang hindi nabali ang kanyang pulso. Ipinaaalala sa akin na kinakailangang baguhin ang setting para sa kanya na tumutukoy kung gaano karaming oras ang wasto sa pagitan ng mga pag-click upang magrehistro ng isang dobleng pag-click ….

Ang data ng mambabasa ng kard na ito ay wastong 1.0 sa amin bago ilagay ang linya sa linya, kaya walang pag-aalala tungkol sa pagkaantala upang mapunta ang iyong sarili sa "kaunting oras." Para sa isang dalawahang mambabasa tulad ng isa na ginagamit ko, mayroong dalawang mga track ng data na magagamit upang mabasa. Sa ible na ito, magpapakita ako ng pagbabasa mula sa pangunahing unang track upang makapagsimula ka. Mayroong limang mga koneksyon na kakailanganin mong gawin (apat kung hindi mo alintana ang pagbibigay ng mas mahusay na tuned control para sa mas kaunting mga I / O port na ginagamit). Suriin ang larawan sa ibaba. Ang pulang kawad ay papunta sa + 5V habang ang itim na kawad ay papunta sa lupa. Ang berdeng kawad ay / CARD_PRESENT; ang dilaw na kawad ay / STROBE, at ang puting kawad ay / DATA1. Ang forward slash (/) ay nangangahulugang ang data ay baligtad. Ang isang mababang signal (ie 0) ay nababasa bilang isang, o mataas. Ang iba pang mga konektor ay kayumanggi para sa / STROBE2 at orange para sa / DATA2. Hindi namin gagamitin ang mga ito. Kung nais mo, maaari mong kalimutan ang tungkol sa / CARD_PRESENT. Ang linya ng data na ito ay bumababa pagkatapos ng halos 17 na pag-ikot ng fluks ng ulo upang ipahiwatig na naroroon ang isang card (sa halip, sabihin, random na ingay na nagdudulot sa iyong mambabasa na magpadala ng bogus na data) at ginagamit upang patunayan na ang data na nakukuha mo ay data ng card at Hindi basura. Maaari mong laktawan ang koneksyon na ito kung suriin mo ang pagsisimula ng sentinel sa stream ng data. Higit pa doon Tulad ng nakikita mo sa ibaba, gumamit ako ng tamang anggulo ng header ng lalaki na konektado sa isang board ng tinapay at ikinonekta iyon ng aking mambabasa. Nakakonekta ako / STROBE sa PIND2 (digital pin 2 sa isang Arduino), / CARD_PRESENT sa PIND3 (para sa mga layunin ng paglalarawan), at / DATA1 sa PIND4. Tiyaking pinagana mo ang mga pullup sa mga pin na ito upang hindi lumutang ang iyong mga pin. Ipinagpalit ko rin ang aking Arduino para sa isang Bare Bones AVR dahil gusto ko ang paraan na umaangkop sa breadboard.

Hakbang 3: Mga Pangunahing Kaalaman sa Card ng Magnetic

Ang pangunahing pag-andar na kakailanganin mong gawin upang mabasa ang isang magnetikong card ay: 1. Tuklasin kung kailan na-swip ang kard 2. Basahin ang stream ng data 3. Tuklasin kung kailan nawala ang kard 4. Iproseso ang data 5. Ipakita ang data Una, ipapakilala ko sa iyo ang ilang mga pangunahing kaalaman sa magnetikong card na kakailanganin mong malaman kapag nagsimula kang magsulat ng iyong sariling code.

Mga Pamantayan sa Magnetic Card

Ang mga kard na pang-magnetiko ay ginawang pamantayan ng ISO sa mga sumusunod na dokumento: 7810 Mga katangiang pisikal ng dokumento ng laki ng credit card 7811-1 Embossing 7811-2 Magnetic stripe - mababang coercivity 7811-3 Lokasyon ng mga embossed character 7811-4 Lokasyon ng mga track na 1 & 2 7811- 5 Lokasyon ng track 3 7811-6 Magnetic stripe - mataas na pamimilit 7813 Mga card ng transaksyon sa pananalapi Tulad ng nakikita mo, ang mga card ng pampinansyal ay tinukoy sa isang hiwalay na dokumento at madalas na may magkakaibang mga format kaysa sa, sabihin mo, ang iyong grocery card o internasyonal na kard sa pagtawag. Kailangan mong mag-program para sa mga pagkakaiba-iba. Mayroon lamang akong credit card at insurance card na madaling gamiting, kaya nagprograma ako para sa mga ganitong uri (na parehong format B).

Mga Format ng Card

Mayroong maraming magkakaibang mga format para sa mga magnetikong card. Karaniwan ang format A at B, na ang B ang pinakakaraniwan na nakita ko, at alin ang sinusuportahan sa code na ito. Ang mga format C sa pamamagitan ng M ay nakalaan sa ISO, naniniwala ako, habang ang N hanggang ?? ay nakalaan para sa pasadyang paggamit ng institusyon. Track 1 Para sa mga financial card, ang unang track ay naitala sa 210 bits kada pulgada at ang unang 0.110 "ng card mula sa itaas. Ang data ay naka-encode bilang" data ng card "bilang 7-bits bawat character. Iyon ay 6-bit para sa ang character at medyo para sa pagkakapantay-pantay. Mayroong ~ 79 mga character na alphanumeric sa track 1. Ang pisikal na pag-order ay paatras. Iyon ay, ang data ay ngunit nakasulat nang paurong sa card (at samakatuwid, basahin ng iyong firmware) bilang. Ang kakaiba ang pagkakapantay-pantay. Ganito ang format ng data ng card:

[SS] [FC] [Pangunahing Account #] [FS] [Pangalan] [FS] [Karagdagang data] [FS] [ES] [LRC] kung saan:

SS Start sentinel FC Format code FS Field separator ES End sentinel LRC Longitudinal Redundancy Check character Subaybayan ang isang SS = '%', FC = isa sa mga format (magiging B ng maraming beses), ang FS ay madalas na '', ang ES ay '?' at ang character na LRC ay karaniwang '<' bagaman hindi ito tinukoy sa mga pamantayan. Bukod sa nakasulat sa card paatras, ang data ay may kakaibang pagkakapareho at 0x20 mula sa ASCII. Hahawakan namin ito kapag pinoproseso namin ang data. Ang Track 2 Track two ay 0.110 "ang lapad at nagsisimula sa 0.110 mula sa tuktok ng card. Ang density ng pag-record ay 75 bits kada pulgada. Ang data ay 5-bits bawat character at binubuo ng humigit-kumulang 40 na mga numerong simbolo lamang. Hindi ka dapat makatagpo ng anumang mga titik sa track na ito. Dapat sundin ng format ng data ng card ang istrakturang ito

[SS] [pangunahing account #] [FS] [karagdagang data | discreditary data] [ES] [LRC]

Ang SS para sa track two ay ang semicolon: ';' at ang FS ay '=' Gamit ang banal na kaalamang ito sa ilalim ng iyong sinturon, magpatuloy sa mga susunod na hakbang upang makita ang pagpapatupad ng code ng pamamaraang nakabalangkas sa itaas.

Hakbang 4: Alamin Kung Ang Isang Card Ay Na-swipe

1. Napansin kung ang card ay na-swipe nang pormal, susuriin ng isa ang pin na / CARD_PRESENT upang makita kung bumaba ito nang mababa. Sa kasamaang palad, hindi talaga ito kinakailangan. Susuriin namin ang wastong card sa paglaon. Bilang kahalili, maaari mong basahin ang iyong strob pin upang makita kung ang mga strobes ay inilagay sa pin, gayunpaman, ito ay makakakuha ka ng maraming orasan na zero. Magpadala ang mambabasa ng halos 60-70 na humahantong sa zero upang ipaalam sa iyo na ang data ay malapit nang ipakita. Gayunpaman, gagamitin namin ang likas na katangian ng binary data upang matukoy kung kailan magsisimulang magrekord ng mga piraso. Ang start sentinel (SS) para sa track one ay ang porsyento ng sign (%). Ang binary na halaga ay 0010 0101 na nangangahulugang maiimbak ito (at basahin) bilang 1010 001 (7-bit ito kaya't ang ika-8 bit ay hindi naililipat). Ngayon, mapapansin ng matalinong mambabasa na kahit paatras ang data hindi ito tumutugma sa halagang binary ASCII. Iyon ay dahil ito ay 0x20 off ng hex. Ang% simbolo ay 0x25 at 0100 0101 ay 0x05. Ang data ng card ay may 0x20 na binawas mula sa halaga. Ang isang nakabitin doon sa mataas na nibble ay ang kakaibang pagkakapareho. Ito ay inilalagay doon upang mayroong isang kakaibang bilang ng "1" s sa halaga. Kaya't dahil alam natin na ang isang wastong card ay palaging magsisimula sa pagsisimula ng sentinel na ito, at dahil ang parity bit ay isang 1, kung gayon kapag nakita namin ang unang TAAS na MABABANG paglipat sa pin ng data, alam namin na nagsimula na kaming makatanggap ng simulan ang sentinel mula sa isang card. Ngayon, hindi ito palaging magiging totoo, at isang walang palya na plano ay suriin ang / CARD_PRESENT card upang malaman kung nawala na ito bilang Mababang bilang karagdagan. Ang pinakasimpleng paraan upang makita ang pagsisimula ng SS, ay upang lumikha ng isang panlabas na makagambala na na-trigger sa bumabagsak na gilid ng / STROBE. Ang data ay may-bisa 1.0 sa amin bago ang pagbagsak ng gilid, kaya kapag na-sample mo ang pagbagsak na gilid, pagkatapos ay alam mo na maaari mong basahin ang / DATA1 pin at makakuha ng isang wastong halaga. Narito ang code upang likhain ang iyong panlabas na nakakagambala na na-trigger sa isang pagbagsak na gilid.

voidInitInterrupt (void) {// Setup makagambala ang BSET (EIMSK, INT0); // external interrupt mask BSET (EICRA, ISC01); // falling edge BCLR (EICRA, ISC00); // falling edge BSET (SREG, 7); // I-bit sa SREG}

Sa aking karaniwang.h na isinasama ko sa lahat ng aking mga programa, ang mga kahulugan ng BSET at BCLR ay matatagpuan. Sumangguni sa file na iyon kung mayroon kang anumang mga katanungan tungkol sa kung paano magtakda ng mga piraso. Ngayon, kapag na-trigger ang pagkagambala, nais naming i-sample ang / DATA1 (sa aking code na tinukoy bilang CARD_DATA) at magtakda ng kaunti sa isang pangkalahatang layunin na rehistro ng IO. Kung nasa ika-7 piraso tayo, i-save ang pagrehistro bilang isang character sa aming global buffer. Gumagamit ako ng isang rehistro ng GPIOR0 sapagkat ito ay mabangis na mabilis na pag-access. Ang pseudo code ay katulad nito:

Itigil ang 16-bit timer I-clear ang timer Kung ang DATA ay LOW Set BIT = 1 sa REGISTER Decrement BIT Set flag kaya hindi na namin laktawan pa ang 0 pa DATA ay HIGH Set BIT = 0 sa REGISTER Decrement BIT Kung BIT ay 0 Magdagdag ng byte sa buffer Increment index I-reset ang BIT

Kung tinatanong mo ang iyong sarili kung bakit ang pagbawas sa halip na pagtaas, tandaan na ang data ay paatras, kaya sa halip na itala ang mga piraso habang nakukuha natin ang mga ito mula sa LSB hanggang MSB, nai-save namin ang mga ito mula sa MSB patungong LSB kaya hindi namin kailangang baligtarin ang mga piraso mamaya kapag pinoproseso ang data. Kung talagang gusto mo, maaari ka ring magdagdag ng 0x20 hex dito, ngunit dahil tungkol sa 5us sa mga strobes na ito, pinapanatili ko ang pagpoproseso sa nakagambalang gawain na ito sa isang minimum.

ISR (INT0_vect) {StopTimer (); ClearTimer (); kung (! BCHK (PIND, CARD_DATA1)) // inverse low = 1 {BSET (GPIOR0, bit); --bit; bDataPresent = 1; } iba pa kung (bDataPresent) {BCLR (GPIOR0, bit); --bit; } kung (bit <0) {buff [idx] = (char) GPIOR0; ++ idx; bit = 6; } StartTimer ();} Kung nagtataka ka tungkol sa kung ano ang tungkol sa negosyo sa tiyempo, saklaw iyon sa hakbang sa pagtukoy kung kailan naiwan ang card sa mambabasa.

Hakbang 5: Basahin ang Stream ng Data

Basahin ang stream ng data

Kaya, naipakita ko na sa iyo kung paano basahin ang data, dahil bahagi ito ng Nakagagambala na Serbisyo para sa aming bumagsak na panlabas na pagkagambala. Ang isang kahaliling pamamaraan ay upang magtakda ng isang watawat sa ISR, at sa pangunahing loop poll ang bandila at basahin ang data sa ganoong paraan, ngunit naniniwala ako na ang paraan na ipinakita ko ay mas malinis. Maging sarili mong hukom at isulat ang sa iyo subalit papayagan ito ng iyong MCU. Sinabi na, magpatuloy tayo upang malaman kung paano makilala kung ang card ay kumukuha ng isang Elvis at umalis na sa gusali.

Hakbang 6: Nakita ang Kardong Iniwan ang Reader

Alamin kung kailan nawala ang isang kard

Pormal, susubukan ng isa ang / CARD_PRESENT pin upang makita kung nawala na ulit ang TAAS, ngunit hindi namin kailangan ng steenkin '/ CARD_PRESENT na kumukuha ng isa pang I / O port. Dito pumapasok ang mga timer na iyon. Sa tuwing tatawagin ang abala dahil nakita namin ang isang bumabagsak na gilid / STROBE, humihinto kami sa isang timer, i-clear ang halaga ng timer at magsimulang magbasa. Kapag natapos namin basahin sinisimulan namin muli ang timer. Ulitin ang ad nauseum, o hanggang sa maabot ng timer ang isang tiyak na halaga. Nangangahulugan iyon na ang huling pagkakagambala ay tinawag at wala nang data na dumating, kaya ipinapalagay namin na iyon na at simulang iproseso ang data na aming nakolekta. Para sa mga timer, gumagamit kami ng TIMER1, ibig sabihin, ang 16-bit timer. Gumagamit ako ng isang 16 Mhz resonator sa labas sa aking AVR. Kung gumagamit ka ng isang arduino, malamang na ikaw din. Kaya, pumili ako ng prescaler na halaga ng 1024 na nangangahulugang bawat (16, 000, 000/1024) beses na tataas ang timer. Iyon ay upang sabihin, ito ay 'tik' 15, 625 beses sa isang segundo. Ang / CARD_PRESENT ay pupunta sa TAAS na nagpapahiwatig na ang card ay naiwan sa mambabasa tungkol sa 150ms pagkatapos ng huling data bit. Alam ito, nagpasya lamang akong suriin ang bawat 1/4 ng isang segundo. Magiging ganito ang hitsura:

(((F_CPU) / PRESCALER) / 4) na kung saan ay nasa paligid ng 3900. Kaya, kapag ang timer counter TCNT1 umabot sa 3900, pagkatapos ay alam ko na ito ay tungkol sa 300ms at maaari kong medyo ligtas na tapusin na ang card ay naiwan sa mambabasa. Madali

#define PRESCALER 1024 # tukuyin ang CHECK_TIME ((F_CPU / PRESCALER) / 4) // 250 ms # tukuyin ang StartTimer () BSET (TCCR1B, CS10), BSET (TCCR1B, CS12) // 1024 prescaler # tukuyin ang StopTimer () BCLR (TCCR1B, CS10), BCLR (TCCR1B, CS12) # tukuyin ang ClearTimer () (TCNT1 = 0) Nakita mo sa ISR kung saan nagsimula ang timer, huminto, at malinis sa bawat nakakagambala. Ngayon, sa pangunahing loop sinusuri lamang namin upang makita kung ang timer counter ay umabot sa aming target na halaga, at kung gayon, simulan ang pagproseso ng data

para sa (;;) {kung (TCNT1> = CHECK_TIME) {

StopTimer (); ClearTimer (); ProcessData (); ReadData (); idx = 0; bit = 6; bDataPresent = 0; memset (& buff, 0, MAX_BUFF_SZ1); }} Ngayon ay ligtas na iproseso ang data

code na na-format ng

Hakbang 7: Iproseso ang Data

Iproseso ang data

Ang yugto ng pagproseso ay binubuo ng:

• pagsuri para sa isang wastong SS
• pagsuri sa pagkakapantay-pantay
• nagko-convert sa ASCII
• pagsuri para sa isang wastong ES
• pagsuri sa LRC

Dito, hindi ako nag-aalala sa pag-check ng pagkakapantay-pantay, tulad ng itinakda ko lamang sa zero. Hindi ko din kinakalkula ang LRC para sa maliit na tutorial na ito. Iyon ay isang bagay na nais ng isang mas lubos na napagtanto firmware na gawin. Narito ang code upang maproseso ang data na ginagawa ang mga hakbang sa itaas (sans ang dating nabanggit). Hanapin ito sa imahe sa ibaba. Ito ay nagkomento at medyo nagpapaliwanag. Isang espesyal na tala sa pagkakapantay-pantay at ASCII: Linisin ko lang ang pagkakatulad ng bit (ika-7 bit … ibig sabihin isang 1 na may 6 na zero sa likod nito) at upang mai-convert mula sa "data ng card" dapat mong idagdag ang 0x20 sa halaga. Tungkol doon.

Hakbang 8: Ipakita ang Data

Ipakita ang data

Ang display ay pupunta sa isang programa ng terminal na partikular kong isinulat para sa pagkonekta sa isang AVR sa pamamagitan ng RS232 o USB. Ang programa ay tinatawag na AVR Terminal. Ang pamamaraang ReadData () ay medyo pangit at hinihikayat kang maghanap ng mas malinis na solusyon kaysa sa naisip ko. Mayroon ding isang output ng pagpapaandar sa AVR Terminal. Ang output ay una sa isang health card card, at ang pangalawa ay isang VISA card. I-click ang sa kaliwang sulok sa itaas ng larawan at piliin ang orihinal o malaking imahe upang makita ito nang mas mahusay.

Hakbang 9: Pag-download ng Code at Pagbalot

Sa itinuturo na ito tinalakay ko ang ilang mga pangunahing kaalaman sa mga mambabasa ng magnetic card at ipinakita sa iyo ang ilang code upang makapagsimula ka sa tamang direksyon sa pagbabasa ng data mula sa mga magnetikong card. Maraming gawain na maaaring magawa, tulad ng pagbabasa at pag-decode ng ika-2 track, pagkalkula ng LRC at pagkalkula ng kakaibang pagkakapareho sa bawat byte. Ang buong code ng mapagkukunan ay magagamit para sa pag-download sa ibaba. Isinulat ito sa AVR Studio 4.17. Inaasahan kong nasiyahan ka sa pagtuturo na ito at, tulad ng lagi, inaasahan ko ang anumang mga komento o mungkahi na maaaring mayroon ka. Maligayang pag-coding at pag-AVR!