अपने Arduino को एक चुंबकीय कार्ड रीडर में बदल दें!: 9 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:24

मेरा मानना है कि सभी ने चुंबकीय कार्ड रीडर का उपयोग किया है। मेरा मतलब है, इन दिनों नकद कौन ले जाता है? उन्हें आपके हाथों को प्राप्त करना मुश्किल नहीं है, और मेरी पसंदीदा स्थानीय इलेक्ट्रॉनिक्स दुकान की यात्रा के दौरान, मुझे इन लोगों से भरा एक बिन मिला। तो….बेशक, मैंने एक उठाया और यह देखने के लिए घर लाया कि मैं इसके साथ किस तरह का सामान कर सकता हूं और एक एवीआर।

यह निर्देश आपको दिखाएगा कि मैगटेक चुंबकीय कार्ड रीडर को AVR या Arduino / क्लोन से कैसे जोड़ा जाए और कार्ड के पहले ट्रैक से डेटा पढ़ा जाए। अपनी सीटों को बंद करो; चुंबकीय कार्ड पाठकों की बिट दर अधिक होती है!

चरण 1: उपकरण सूची

यहां कुछ चीजें दी गई हैं जिनकी आपको शुरुआत करने की आवश्यकता होगी।

• चुंबकीय कार्ड रीडर (मेरा एक मैगेटक 90 मिमी डुअल-हेड रीडर है। $ 5.00)
• AVR, Arduino, या क्लोन (ATmega328p ~ $4.30 Mouser.com से
• सोल्डरलेस ब्रेडबोर्ड
• कुछ तार
• हो सकता है कि एक हेडर अगर आपको उस तरह की चीज पसंद है।
• अपने सीरियल पोर्ट को पढ़ने के लिए कुछ। मैं BattleDroids.net से AVR टर्मिनल का उपयोग करता हूं

आरंभ करने के लिए आपको बस इतना ही चाहिए। आपके द्वारा प्राप्त किए जाने वाले मैगकार्ड रीडर के आधार पर, आपको अपने विशिष्ट पाठक के साथ काम करने के लिए इन निर्देशों और निश्चित रूप से कोड को संशोधित करना पड़ सकता है। हालांकि, मैंने जो कोड लिखा है वह आपको बहुत दूर ले जाना चाहिए, मुझे आशा है।

चरण 2: सेल्फ-क्लॉकिंग मैग्नेटिक कार्ड रीडर्स

चुंबकीय कार्ड रीडर "सेल्फ-क्लॉकिंग" हैं, जिसका अर्थ है कि वे एक स्ट्रोब नामक घड़ी प्रदान करते हैं, जिसके विरुद्ध कनेक्टेड माइक्रोकंट्रोलर सिंक कर सकता है। यह एक वरदान है। इसका मतलब है कि आपको क्लॉकिंग सिग्नल की तलाश करने और सिग्नल को सीधे क्लॉक पल्स पर सेंटर करने के बारे में चिंता करने की ज़रूरत नहीं है, और क्लॉक सिग्नल के स्वीट स्पॉट में कोई परेशानी नहीं है। जब आप कार्ड स्वाइप के बारे में सोचते हैं तो यह समझ में आता है: हर कोई अलग गति से स्वाइप करता है, कुछ धीमा, कुछ दूसरों की तुलना में तेज़। सेल्फ-क्लॉकिंग मेरी प्यारी दादी को भी अपनी कलाई को तोड़े बिना अपने कार्ड का उपयोग करने की क्षमता देता है। मुझे उसके लिए सेटिंग बदलने की याद दिलाता है जो यह निर्धारित करती है कि डबल-क्लिक दर्ज करने के लिए क्लिक के बीच कितना समय मान्य है…।

स्ट्रोब को लाइन में लगाने से पहले इस कार्ड रीडर का डेटा 1.0 हमें मान्य है, इसलिए खुद को "बिट टाइम" में लाने में देरी करने की कोई चिंता नहीं है। मेरे द्वारा उपयोग किए जा रहे ड्यूल हेड रीडर के लिए, पढ़ने के लिए दो डेटा ट्रैक उपलब्ध हैं। इस 'ible' में, मैं आपको आरंभ करने के लिए प्राथमिक पहले ट्रैक से पठन दिखाने जा रहा हूँ। आपको पांच कनेक्शन बनाने की आवश्यकता होगी (चार अगर आपको कम I/O बंदरगाहों के उपयोग के लिए अधिक बढ़िया ट्यून नियंत्रण छोड़ने में कोई फर्क नहीं पड़ता)। नीचे दी गई तस्वीर को देखें। लाल तार +5V पर जाता है जबकि काला तार जमीन पर जाता है। हरा तार /CARD_PRESENT है; पीला तार /STROBE है, और सफेद तार /DATA1 है। फॉरवर्ड स्लैश (/) का मतलब है कि डेटा उल्टा है। एक कम सिग्नल (यानी 0) को एक या उच्च के रूप में पढ़ा जाता है। अन्य कनेक्टर /STROBE2 के लिए भूरे और /DATA2 के लिए नारंगी हैं। हम इनका उपयोग नहीं करेंगे। यदि आप चाहें, तो आप /CARD_PRESENT को भूल सकते हैं। यह डेटा लाइन लगभग 17 हेड फ्लक्स रोटेशन के बाद कम हो जाती है, यह इंगित करने के लिए कि एक कार्ड मौजूद है (इसके बजाय, यादृच्छिक शोर के कारण आपके पाठक को फर्जी डेटा भेजना पड़ता है) और इसका उपयोग यह सत्यापित करने के लिए किया जाता है कि आपको जो डेटा मिल रहा है वह कार्ड डेटा है और कचरा नहीं। यदि आप डेटा स्ट्रीम पर प्रारंभ प्रहरी की जांच करते हैं तो आप इस कनेक्शन को छोड़ सकते हैं। उस पर और बाद में। जैसा कि आप नीचे देख सकते हैं, मैंने ब्रेड बोर्ड से जुड़े एक समकोण पुरुष हेडर का उपयोग किया और अपने पाठक को उससे जोड़ा। मैंने /STROBE को PIND2 (एक Arduino पर डिजिटल पिन 2), /CARD_PRESENT से PIND3 (चित्रण उद्देश्यों के लिए), और /DATA1 को PIND4 से जोड़ा। सुनिश्चित करें कि आप इन पिनों पर पुलअप सक्षम करते हैं ताकि आपके पिन तैरें नहीं। मैंने अपने Arduino को बेयर बोन्स AVR के लिए भी ट्रेड किया क्योंकि मुझे यह पसंद है कि यह ब्रेडबोर्ड में फिट बैठता है।

चरण 3: चुंबकीय कार्ड मूल बातें

चुंबकीय कार्ड पढ़ने के लिए आपको जो प्राथमिक कार्य करने होंगे, वे हैं: 1. पता लगाएं कि कार्ड कब स्वाइप किया गया है 2. डेटा की धारा पढ़ें 3. पता लगाएं कि कार्ड कब चला गया है 4. डेटा संसाधित करें 5. प्रदर्शित करें डेटा सबसे पहले, मैं आपको कुछ चुंबकीय कार्ड मूल बातें बताऊंगा जिन्हें आपको अपना कोड लिखना शुरू करते समय जानना होगा।

चुंबकीय कार्ड मानक

चुंबकीय कार्ड आईएसओ द्वारा निम्नलिखित दस्तावेजों में मानकीकृत किए गए हैं: 7810 क्रेडिट कार्ड आकार दस्तावेज़ की भौतिक विशेषताएं 7811-1 एम्बॉसिंग 7811-2 चुंबकीय पट्टी - कम जबरदस्ती 7811-3 उभरा पात्रों का स्थान 7811-4 पटरियों का स्थान 1 और 2 7811- ५ ट्रैक का स्थान ३ ७८११-६ चुंबकीय पट्टी - उच्च जबरदस्ती ७८१३ वित्तीय लेनदेन कार्ड जैसा कि आप देख सकते हैं, वित्तीय कार्ड एक अलग दस्तावेज़ में निर्दिष्ट होते हैं और अक्सर आपके किराना कार्ड या अंतरराष्ट्रीय कॉलिंग कार्ड की तुलना में अलग-अलग प्रारूप होते हैं। आपको इन अंतरों के लिए प्रोग्राम करना होगा। मेरे पास बस एक क्रेडिट कार्ड और बीमा कार्ड था, इसलिए मैंने इन प्रकारों के लिए प्रोग्राम किया (जो दोनों प्रारूप बी होते हैं)।

कार्ड प्रारूप

चुंबकीय कार्ड के लिए कई अलग-अलग प्रारूप हैं। प्रारूप ए और बी आम हैं, बी सबसे आम मैंने देखा है, और जो इस कोड में समर्थित है। प्रारूप सी से एम आईएसओ द्वारा आरक्षित हैं, मुझे विश्वास है, जबकि एन के माध्यम से ?? संस्थागत कस्टम उपयोग के लिए आरक्षित हैं। ट्रैक 1 वित्तीय कार्ड के लिए, पहला ट्रैक 210 बिट प्रति इंच पर रिकॉर्ड किया गया है और ऊपर से कार्ड का पहला 0.110 "है। डेटा को "कार्ड डेटा" के रूप में 7-बिट प्रति वर्ण के रूप में एन्कोड किया गया है। यह 6-बिट के लिए है चरित्र और समानता के लिए थोड़ा सा। ट्रैक पर ~ 79 अल्फ़ान्यूमेरिक वर्ण हैं। भौतिक क्रम पीछे की ओर है। यानी, डेटा है, लेकिन यह कार्ड पर पीछे की ओर लिखा गया है (और इसलिए, आपके फर्मवेयर द्वारा पढ़ा जाएगा)। समता विषम है। कार्ड डेटा प्रारूप इस तरह दिखता है:

[एसएस] [एफसी] [प्राथमिक खाता #] [एफएस] [नाम] [एफएस] [अतिरिक्त डेटा] [एफएस] [ईएस] [एलआरसी] जहां:

SS प्रारंभ प्रहरी FC स्वरूप कोड FS फ़ील्ड विभाजक ES अंतिम प्रहरी LRC अनुदैर्ध्य अतिरेक जाँच वर्ण ट्रैक एक एसएस = '%', एफसी = प्रारूपों में से एक (कई बार बी होने जा रहा है), एफएस अक्सर '', ईएस है'?' और एलआरसी वर्ण आमतौर पर '<' होता है, हालांकि यह मानकों में निर्दिष्ट नहीं है। कार्ड के पीछे लिखे जाने के अलावा, डेटा में एक विषम समता बिट है और ASCII से 0x20 है। जब हम डेटा संसाधित करेंगे तो हम इसे संभाल लेंगे। ट्रैक 2 ट्रैक दो 0.110 "चौड़ा है और कार्ड के ऊपर से 0.110 शुरू होता है। इसकी रिकॉर्डिंग घनत्व 75 बिट प्रति इंच है। डेटा प्रति वर्ण 5-बिट है और इसमें लगभग 40 संख्यात्मक प्रतीक हैं। आपको किसी का सामना नहीं करना चाहिए इस ट्रैक पर अक्षर। कार्ड डेटा प्रारूप को इस संरचना का पालन करना चाहिए

[एसएस] [प्राथमिक खाता #] [एफएस] [अतिरिक्त डेटा | विवेकाधीन डेटा] [ईएस] [एलआरसी]

ट्रैक दो के लिए SS अर्धविराम है: ';' और FS '=' है, इस पवित्र ज्ञान के साथ, ऊपर उल्लिखित प्रक्रिया को लागू करने वाले कोड को देखने के लिए अगले चरणों पर जारी रखें।

चरण 4: पता लगाएं कि कार्ड कब स्वाइप किया गया है

1. पता लगाएं कि जब कोई कार्ड औपचारिक रूप से स्वाइप किया गया है, तो कोई /CARD_PRESENT पिन की जांच करेगा कि यह नीचे गिरा है या नहीं। सौभाग्य से, यह वास्तव में आवश्यक नहीं है। हम बाद में वैध कार्ड की जांच करेंगे। वैकल्पिक रूप से, आप अपने स्ट्रोब पिन को यह देखने के लिए पढ़ सकते हैं कि स्ट्रोब को पिन पर कब रखा गया है, हालांकि, यह आपको बहुत सारे क्लॉकिंग ज़ीरो को नेट करेगा। पाठक आपको यह बताने के लिए लगभग 60-70 अग्रणी शून्य भेजेगा कि डेटा प्रस्तुत किया जाने वाला है। हालांकि, हम यह निर्धारित करने के लिए बाइनरी डेटा की प्रकृति का उपयोग करने जा रहे हैं कि बिट्स की रिकॉर्डिंग कब शुरू की जाए। ट्रैक एक के लिए प्रारंभ प्रहरी (एसएस) प्रतिशत चिह्न (%) है। इसका बाइनरी मान 0010 0101 है जिसका अर्थ है कि इसे 1010 001 के रूप में संग्रहीत (और पढ़ा जाएगा) किया जाएगा (यह 7-बिट है इसलिए 8 वां बिट प्रसारित नहीं होता है)। अब, चतुर पाठक यह नोटिस करेगा कि भले ही डेटा पीछे की ओर है, यह बाइनरी ASCII मान से मेल नहीं खाता है। ऐसा इसलिए है क्योंकि यह हेक्स से 0x20 दूर है। % प्रतीक 0x25 है और 0100 0101 0x05 है। कार्ड डेटा में मान से 0x20 घटाया गया है। वह जो ऊँचे कुतरने में वहाँ लटका हुआ है वह विषम समता बिट है। इसे वहां रखा गया है ताकि मान में "1" की विषम संख्या हो। इसलिए क्योंकि हम जानते हैं कि एक वैध कार्ड हमेशा इस प्रारंभ प्रहरी के साथ शुरू होगा, और क्योंकि समता बिट 1 है, तो जब हम डेटा पिन पर पहले उच्च से निम्न संक्रमण का पता लगाते हैं, तो हम जानते हैं कि हमने अभी प्राप्त करना शुरू किया है एक कार्ड से प्रहरी प्रारंभ करें। अब, यह हमेशा सत्य नहीं होगा, और यह देखने के लिए /CARD_PRESENT कार्ड की जांच करना एक आसान योजना होगी कि क्या यह इसके अतिरिक्त कम हो गया है। SS की शुरुआत का पता लगाने का सबसे सरल तरीका है, /STROBE के गिरते किनारे पर एक बाहरी रुकावट पैदा करना। डेटा गिरने वाले किनारे से पहले 1.0 मान्य है, इसलिए जब आपने गिरने वाले किनारे का नमूना लिया है, तो आप जानते हैं कि आप /DATA1 पिन पढ़ सकते हैं और एक वैध मान प्राप्त कर सकते हैं। गिरने वाले किनारे पर ट्रिगर होने वाली आपकी बाहरी बाधा बनाने के लिए कोड यहां दिया गया है।

voidInitInterrupt(void){// सेटअप इंटरप्ट BSET (EIMSK, INT0); // बाहरी इंटरप्ट मास्क BSET (EICRA, ISC01); // गिरने वाला किनारा बीसीएलआर (ईआईसीआरए, आईएससी 00); // गिरने वाला किनारा बीएसईटी (एसआरईजी, 7); // एसआरईजी में आई-बिट}

अपने सभी कार्यक्रमों में जो मैं शामिल करता हूं, उसमें बीएसईटी और बीसीएलआर की परिभाषाएं पाई जा सकती हैं। उस फ़ाइल का संदर्भ लें, क्या आपके पास बिट्स सेट करने के बारे में कोई प्रश्न होना चाहिए। अब, जब रुकावट शुरू हो जाती है, तो हम /DATA1 (मेरे कोड में CARD_DATA के रूप में परिभाषित) का नमूना लेना चाहते हैं और एक सामान्य उद्देश्य IO रजिस्टर में थोड़ा सा सेट करना चाहते हैं। यदि हम 7वें बिट पर हैं, तो रजिस्टर को हमारे वैश्विक बफर में एक चरित्र के रूप में सहेजें। मैं एक GPIOR0 रजिस्टर का उपयोग करता हूं क्योंकि यह तेज तेज पहुंच है। छद्म कोड कुछ इस तरह है:

16-बिट टाइमर बंद करें टाइमर साफ़ करें यदि डेटा कम है तो सेट करें बिट = 1 रजिस्टर में कमी बिट सेट ध्वज ताकि हम किसी और को छोड़ न दें 0 और डेटा उच्च सेट बिट = 0 रजिस्टर डिक्रीमेंट बिट में है यदि बीआईटी 0 है तो बफर में बाइट जोड़ें इंक्रीमेंट इंडेक्स रीसेट BIT

यदि आप अपने आप से पूछ रहे हैं कि वेतन वृद्धि के बजाय कमी क्यों है, तो याद रखें कि डेटा पीछे की ओर है, इसलिए बिट्स को रिकॉर्ड करने के बजाय जैसे हम उन्हें एलएसबी से एमएसबी में प्राप्त करते हैं, हम उन्हें एमएसबी से एलएसबी में सहेजते हैं, इसलिए हमें बिट्स को उलटने की आवश्यकता नहीं है। बाद में डेटा संसाधित करते समय। यदि आप वास्तव में चाहते थे, तो आप यहां 0x20 हेक्स भी जोड़ सकते हैं, लेकिन चूंकि यह इन स्ट्रोब पर लगभग 5us है, इसलिए मैं इस इंटरप्ट सर्विस रूटीन में प्रोसेसिंग को न्यूनतम रख रहा हूं।

ISR (INT0_vect) {स्टॉपटाइमर (); क्लियरटाइमर (); अगर (!BCHK(PIND, CARD_DATA1)) // उलटा कम = 1 {बीएसईटी (GPIOR0, बिट); --अंश; bDataPresent = 1; } और अगर (bDataPresent) {BCLR (GPIOR0, बिट); --अंश; } अगर (बिट <0) {बफ [idx] = (चार) GPIOR0; ++आईडीएक्स; बिट = 6; } स्टार्टटाइमर ();} यदि आप सोच रहे हैं कि टाइमिंग व्यवसाय किस बारे में है, तो यह निर्धारित करने के चरण में शामिल है कि कार्ड ने पाठक को कब छोड़ा है।

चरण 5: डेटा स्ट्रीम पढ़ें

डेटा की धारा पढ़ें

ठीक है, मैंने आपको पहले ही दिखाया है कि डेटा को कैसे पढ़ा जाए, क्योंकि यह हमारे गिरने वाले बाहरी व्यवधान के लिए इंटरप्ट सर्विस रूटीन का हिस्सा है। आईएसआर में ध्वज सेट करने का एक वैकल्पिक तरीका होगा, और मुख्य लूप में ध्वज को मतदान करना और डेटा को इस तरह पढ़ना, लेकिन मेरा मानना है कि जिस तरह से मैंने इसे प्रस्तुत किया है वह क्लीनर है। अपने स्वयं के न्यायाधीश बनें और अपना लिखें हालांकि आपका एमसीयू इसे अनुमति देगा। ऐसा कहा जा रहा है, आइए यह पता लगाने के लिए आगे बढ़ें कि कार्ड एल्विस को कब खींचता है और इमारत छोड़ देता है।

चरण 6: रीडर को छोड़कर कार्ड का पता लगाएं

पता लगाएं कि कोई कार्ड कब चला गया

औपचारिक रूप से, कोई यह देखने के लिए /CARD_PRESENT पिन का नमूना लेगा कि क्या यह फिर से उच्च हो गया है, लेकिन हमें किसी अन्य I/O पोर्ट को लेने के लिए स्टीनकिन/CARD_PRESENT की आवश्यकता नहीं है। यह वह जगह है जहां वे टाइमर आते हैं। हर बार इंटरप्ट को कॉल किया जाता है क्योंकि हमने /STROBE पर गिरने वाले किनारे का पता लगाया है, हम एक टाइमर रोकते हैं, टाइमर मान साफ़ करते हैं और पढ़ना शुरू करते हैं। जब हम पढ़ना समाप्त कर लेते हैं तो हम फिर से टाइमर शुरू करते हैं। रुक-रुक कर या टाइमर के एक निश्चित मूल्य तक पहुंचने तक दोहराएं। इसका मतलब है कि आखिरी इंटरप्ट को बुलाया गया है और कोई और डेटा नहीं आया है, इसलिए हम मानते हैं कि यही वह है और हमने जो डेटा एकत्र किया है उसे संसाधित करना शुरू कर दिया है। टाइमर के लिए, हम TIMER1, यानी 16-बिट टाइमर का उपयोग करते हैं। मैं अपने एवीआर के लिए बाहरी रूप से 16 मेगाहर्ट्ज रेज़ोनेटर का उपयोग कर रहा हूं। यदि आप एक arduino का उपयोग कर रहे हैं, तो आप भी शायद हैं। इसलिए, मैंने १०२४ का प्रीस्केलर मान चुना है जिसका अर्थ है कि प्रत्येक (१६,०००,०००/10२४) बार टाइमर बढ़ेगा। यानी यह एक सेकेंड में 15,625 बार 'टिक' करेगा। /CARD_PRESENT यह दर्शाता है कि पिछले डेटा बिट के बाद कार्ड ने पाठक को लगभग 150ms छोड़ दिया है। यह जानकर, मैंने बस एक सेकंड के प्रत्येक 1/4 भाग की जाँच करने का निर्णय लिया। यह कुछ इस तरह दिखेगा:

(((F_CPU) / प्रेस्कलर) / 4) जो लगभग ३९०० हो जाता है। इसलिए, जब टाइमर काउंटर TCNT1 ३९०० तक पहुंचता है, तो मुझे पता है कि यह लगभग ३००ms हो गया है और मैं बहुत सुरक्षित रूप से यह निष्कर्ष निकाल सकता हूं कि कार्ड ने पाठक को छोड़ दिया है। आसान

#define PRESCALER 1024#परिभाषित करें CHECK_TIME ((F_CPU / PRESCALER) / 4) // 250 एमएस # परिभाषित StartTimer () BSET (TCCR1B, CS10), BSET (TCCR1B, CS12) // 1024 प्रीस्केलर # स्टॉपटाइमर को परिभाषित करें () BCLR (TCCR1B), CS10), BCLR (TCCR1B, CS12) # ClearTimer () (TCNT1 = 0) परिभाषित करें आपने ISR में देखा है, जहां टाइमर शुरू होता है, बंद हो जाता है, और प्रत्येक रुकावट पर साफ़ हो जाता है। अब, मुख्य लूप में हम सिर्फ यह देखने के लिए जांचते हैं कि टाइमर काउंटर हमारे लक्ष्य मूल्य तक पहुंच गया है या नहीं, और यदि ऐसा है, तो डेटा प्रोसेसिंग शुरू करें

के लिए (;;){ अगर(TCNT1>= CHECK_TIME) {

स्टॉपटाइमर (); क्लियरटाइमर (); डेटा का प्रसंस्करण(); रीडडाटा (); आईडीएक्स = 0; बिट = 6; बीडाटाप्रेजेंट = 0; मेमसेट (और बफ, 0, MAX_BUFF_SZ1); } } अब डेटा को प्रोसेस करना सुरक्षित है

manoli.net/csharpformat/ द्वारा स्वरूपित कोड

चरण 7: डेटा संसाधित करें

डेटा संसाधित करें

प्रसंस्करण चरण में निम्न शामिल हैं:

• एक वैध SS. के लिए जाँच कर रहा है
• जाँच समता
• ASCII में कनवर्ट करना
• एक वैध ES. के लिए जाँच कर रहा है
• एलआरसी की जाँच

यहाँ, मैं समता की जाँच से परेशान नहीं हूँ, क्योंकि मैंने अभी उस बिट को शून्य पर सेट किया है। मैं इस छोटे से ट्यूटोरियल के लिए LRC की गणना भी नहीं करता। यह कुछ ऐसा होगा जो एक अधिक पूर्ण रूप से महसूस किया गया फर्मवेयर करना चाहेगा। यहां उपरोक्त चरणों को करने वाले डेटा को संसाधित करने के लिए कोड है (पहले उल्लेख किए गए बिना)। इसे नीचे दी गई छवि में खोजें। यह टिप्पणी की गई है और बहुत आत्म-व्याख्यात्मक है। समता और एएससीआईआई पर एक विशेष नोट: मैं बस समता बिट (सातवाँ बिट … यानी इसके पीछे 6 शून्य के साथ 1) को साफ़ करता हूं और "कार्ड डेटा" से कनवर्ट करने के लिए आपको मान में 0x20 जोड़ना होगा। यह इसके बारे में।

चरण 8: डेटा प्रदर्शित करें

डेटा प्रदर्शित करें

डिस्प्ले एक टर्मिनल प्रोग्राम में जाता है जिसे मैंने विशेष रूप से RS232 या USB के माध्यम से AVR से कनेक्ट करने के लिए लिखा था। कार्यक्रम को एवीआर टर्मिनल कहा जाता है। ReadData() विधि बहुत बदसूरत है और आपको मेरे द्वारा लाए गए समाधान की तुलना में एक क्लीनर समाधान खोजने के लिए प्रोत्साहित किया जाता है। AVR टर्मिनल में फ़ंक्शन का एक आउटपुट भी है। आउटपुट पहला स्वास्थ्य बीमा कार्ड का है, और दूसरा वीज़ा कार्ड का है। चित्र के ऊपरी बाएँ कोने में पर क्लिक करें और इसे बेहतर देखने के लिए मूल या बड़ी छवि चुनें।

चरण 9: कोड डाउनलोड और रैपअप

इस निर्देश में मैंने मैग्नेटिक कार्ड रीडर्स की कुछ बुनियादी बातों पर चर्चा की है और आपको मैग्नेटिक कार्ड से डेटा पढ़ने में सही दिशा में आरंभ करने के लिए कुछ कोड दिखाए हैं। और भी बहुत से काम हैं जो किए जा सकते हैं, जैसे दूसरे ट्रैक को पढ़ना और डिकोड करना, एलआरसी की गणना करना और प्रत्येक बाइट पर विषम समता की गणना करना। पूर्ण स्रोत कोड नीचे डाउनलोड के लिए उपलब्ध है। यह एवीआर स्टूडियो 4.17 में लिखा गया था। मुझे आशा है कि आपने इस निर्देश का आनंद लिया है और हमेशा की तरह, मैं आपके किसी भी टिप्पणी या सुझाव के लिए तत्पर हूं। हैप्पी कोडिंग और AVR'ing!