הפוך את הארדואינו שלך לקורא כרטיסים מגנטיים !: 9 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:18

אני מאמין שכולם השתמשו בקורא כרטיסים מגנטי. כלומר, מי נושא מזומנים בימים אלה? גם להם לא קשה לשים ידיים ובמהלך טיול בחנות האלקטרוניקה המקומית האהובה עלי מצאתי פח מלא בחבר'ה האלה. אז … כמובן, לקחתי אחד והבאתי אותו הביתה כדי לראות איזה סוג של דברים אני יכול לעשות עם זה ו- AVR.

מדריך זה יראה לך כיצד לחבר קורא כרטיסים מגנטיים מסוג Magtek ל- AVR או Arduino/שיבוט ולקרוא נתונים מהרצועה הראשונה של הכרטיס. חגרו את המושבים שלכם; לקוראי כרטיסים מגנטיים יש קצב סיביות גבוה!

שלב 1: רשימת הציוד

להלן כמה דברים שתצטרך כדי להתחיל.

• קורא כרטיסים מגנטיים (שלי הוא קורא Magetk 90 מ"מ בעל ראש כפול. $ 5.00)
• AVR, Arduino או שיבוט (ATmega328p ~ $ 4.30 מאת Mouser.com
• קרש לחם ללא הלחמה
• קצת חוט
• אולי כותרת אם אתה אוהב דבר כזה.
• משהו לקרוא את הפורט הסידורי שלך. אני משתמש במסוף AVR מ- BattleDroids.net

זה כל מה שאתה צריך כדי להתחיל. בהתאם לקורא ה- magcard שתקבל בסופו של דבר, ייתכן שתצטרך לשנות את ההוראות הללו, ובטוח ביותר את הקוד, כדי לעבוד עם הקורא הספציפי שלך. עם זאת, הקוד שכתבתי אמור להביא אותך די רחוק, אני מקווה.

שלב 2: קוראי כרטיסים מגנטיים עם שעון עצמי

קוראי כרטיסים מגנטיים הם "שעונים עצמית", כלומר הם מספקים שעון הנקרא strobe, נגדו יכול המיקרו-בקר המחובר לסנכרן. זהו ברכה. זה אומר שאתה לא צריך לדאוג לחפש אות שעון ולתזמן את האות למרכז ישירות על דופק השעון, ושלא תנודד טורדני אל הנקודה המתוקה של אות השעון. זה הגיוני כשאתה חושב על החלקות כרטיסים: כל אחד סוחב בקצב אחר, חלקם איטי יותר, חלקם מהר יותר מאחרים. שעון עצמי מאפשר אפילו לסבתא המתוקה שלי את היכולת להשתמש בכרטיס שלה מבלי לשבור את פרק ידה. מזכיר לי שהייתי צריך לשנות עבורה את ההגדרה שקובעת כמה זמן תקף בין קליקים לרישום לחיצה כפולה ….

נתוני קורא הכרטיסים הזה תקפים 1.0 לנו לפני הכנסת הקובץ, כך שאין לך מה לדאוג לעכב את עצמך ב"זמן הסיביות ". עבור קורא ראש כפול כמו זה שבו אני משתמש, ישנם שני מסלולי נתונים הזמינים לקריאה. בפרק זה, אני הולך להראות קריאה מהמסלול הראשון הראשי כדי להתחיל. ישנם חמישה חיבורים שתצטרך לבצע (ארבעה אם לא אכפת לך לוותר על שליטה מכוונת יותר עבור פחות יציאות קלט/פלט בשימוש). בדוק את התמונה למטה. החוט האדום עובר ל- +5V ואילו החוט השחור עובר לקרקע. החוט הירוק הוא /CARD_PRESENT; החוט הצהוב הוא /STROBE, והחוט הלבן הוא /DATA1. המשנה קדימה (/) פירושה שהנתונים הפוכים. אות נמוך (קרי 0) נקרא כאחד, או גבוה. המחברים האחרים חומים עבור /STROBE2 וכתומים עבור /DATA2. לא נשתמש באלה. אם תרצה, תוכל לשכוח את /CARD_PRESENT. קו נתונים זה יורד לאחר כ -17 סיבובי שטף ראש כדי להצביע על כך שיש כרטיס (במקום, למשל, רעש אקראי שגורם לקורא שלך לשלוח נתונים מזויפים) ומשמש לאימות שהנתונים שאתה מקבל הם נתוני כרטיס ו לא זבל. אתה יכול לדלג על חיבור זה אם אתה בודק את זקיף ההתחלה בזרם הנתונים. עוד על כך בהמשך. כפי שניתן לראות להלן, השתמשתי בכותרת זכר זווית המחוברת ללוח לחם וחיברתי את הקורא שלי לזה. התחברתי /STROBE ל- PIND2 (סיכה דיגיטלית 2 על Arduino), /CARD_PRESENT ל- PIND3 (למטרות המחשה), ו /DATA1 ל- PIND4. וודא שאתה מפעיל עיגולים על סיכות אלה כדי שהסיכות שלך לא יצופו. החלפתי גם את הארדואינו שלי ב- AVR Bare Bones כי אני אוהב את האופן שבו הוא משתלב בלוח הלחם.

שלב 3: יסודות הכרטיס המגנטי

הפונקציות העיקריות שתצטרך לבצע בכדי לקרוא כרטיס מגנטי הן: 1. זיהוי כאשר הכרטיס הוחלק 2. קרא את זרם הנתונים 3. זיהוי כאשר הכרטיס הלך 4. עיבד את הנתונים 5. הצג את נתונים ראשית, אכיר לך כמה יסודות בכרטיס מגנטי שתצטרך לדעת כאשר תתחיל לכתוב קוד משלך.

תקני כרטיסים מגנטיים

כרטיסים מגנטיים מתוקננים על ידי ה- ISO במסמכים הבאים: 7810 מאפיינים פיזיים של מסמך גודל כרטיס האשראי 7811-1 הבלטה 7811-2 פס מגנטי-כפייתיות נמוכה 7811-3 מיקום תווים מובלטים 7811-4 מיקום הרצועות 1 & 2 7811- 5 מיקום המסילה 3 7811-6 פס מגנטי - כפייתיות גבוהה 7813 כרטיסי עסקה פיננסיים כפי שאתה יכול לראות, כרטיסים פיננסיים מפורטים במסמך נפרד ולרוב יש להם פורמטים שונים מאשר, למשל, כרטיס המכולת שלך או כרטיס הביקור הבינלאומי. יהיה עליך לתכנת הבדלים אלה. היה לי רק כרטיס אשראי וכרטיס ביטוח בהישג יד, אז תיכננתי עבור סוגים אלה (ששניהם הם בפורמט B).

פורמטים של כרטיסים

ישנם מספר פורמטים שונים לכרטיסים מגנטיים. פורמט A ו- B נפוצים, כאשר B הוא השכיח ביותר שראיתי, ואשר נתמך בקוד זה. אני מאמין שתבניות C עד M שמורות ל- ISO, בעוד N עד ?? שמורות לשימוש מותאם אישית מוסדי. מסלול 1 לכרטיסים פיננסיים, המסלול הראשון נרשם ב -210 סיביות לאינץ 'והוא ה- 0.110 "הראשון של הכרטיס מלמעלה. הנתונים מקודדים כ"נתוני כרטיס" כ -7 סיביות לכל תו. זה 6 סיביות עבור הדמות וקצת לזוגיות. ישנם מס '79 תווים אלפאנומריים על מסלול 1. הסדר הפיזי הוא לאחור. כלומר, הנתונים הם אך הם נכתבים לאחור על הכרטיס (ומכאן יקראו על ידי הקושחה שלך) כ. זוגיות מוזרה. פורמט נתוני הכרטיס נראה כך:

[SS] [FC] [חשבון ראשי מספר] [FS] [שם] [FS] [נתונים נוספים] [FS] [ES] [LRC] היכן:

SS Start זקיף FC קוד פורמט FS מפריד שדות ES סוף זקיף LRC יתירות אורך בדוק תו עקוב אחר SS אחד = '%', FC = אחד הפורמטים (הולך להיות B הרבה פעמים), FS הוא לעתים קרובות '', ES הוא '?' ותו LRC הוא בדרך כלל '<' למרות שהוא אינו מצוין בתקנים. מלבד היותו כתוב על הכרטיס לאחור, לנתונים יש סיביות זוגיות משונה והם 0x20 מ- ASCII. אנו נטפל בזה כאשר נעבד את הנתונים. מסלול 2 רוחב מס '2 הוא ברוחב 0.110 אינץ' ומתחיל 0.110 מהחלק העליון של הכרטיס. צפיפות ההקלטה שלו היא 75 סיביות לאינץ '. הנתונים הם 5 סיביות לכל תו ומורכבים מכ -40 סמלים מספריים בלבד. אסור להיתקל בכל אותיות במסלול זה. פורמט נתוני הכרטיס אמור לעקוב אחר מבנה זה

[SS] [חשבון ראשי מספר] [FS] [נתונים נוספים | נתונים שיקוליים] [ES] [LRC]

ה- SS למסלול השני הוא נקודה הפסיק: ';' ו- FS הוא '=' עם הידע הקדוש הזה מתחת לחגורתך, המשך לשלבים הבאים כדי לראות קוד המיישם את ההליך המתואר לעיל.

שלב 4: זיהוי כאשר כרטיס מוחלק

1. לזהות כאשר כרטיס הוחלק באופן רשמי, היה בודק את הסיכה /CARD_PRESENT אם הוא ירד. למרבה המזל, זה לא ממש נחוץ. נבדוק אם הכרטיס תקף מאוחר יותר. לחלופין, אתה יכול לקרוא את סיכת החבטות שלך כדי לראות מתי חבטות הונחו על הסיכה, אולם זה יביא לך הרבה אפס שעונים. הקורא ישלח כ- 60-70 אפסים מובילים כדי ליידע אותך כי נתונים עומדים להיות מוצגים. עם זאת, אנו הולכים להשתמש באופי הנתונים הבינארי כדי לקבוע מתי להתחיל להקליט סיביות. זקיף ההתחלה (SS) למסלול הראשון הוא סימן האחוזים (%). הערך הבינארי שלו הוא 0010 0101 מה שאומר שהוא יאוחסן (ויקרא) כ- 1010 001 (הוא 7 סיביות כך שהסיביות השמונה לא מועברת). כעת, הקורא החכם יבחין כי למרות שהנתונים לאחור הם אינם תואמים לערך ASCII הבינארי. זה בגלל שזה 0x20 הנחה על hex. סמל % הוא 0x25 ו 0100 0101 הוא 0x05. נתוני הכרטיס מופחתים מהערך. זה שמסתובב שם בנשנש הגבוה הוא חלק הזוגיות המוזר. הוא ממוקם שם כך שיש ערך אי זוגי של "1". אז מכיוון שאנו יודעים שכרטיס תקף תמיד יתחיל עם זקיף ההתחלה הזה, ומכיוון שסיביות השוויון היא 1, אז כשאנחנו מזהים את המעבר הראשון גבוה עד נמוך בסיכת הנתונים, אז אנחנו יודעים שהתחלנו לקבל את התחל זקיף מכרטיס. עכשיו, זה לא תמיד יהיה נכון, ותוכנית חסינת טפשים תהיה לבדוק את כרטיס /CARD_PRESENT כדי לראות אם הוא ירד בנוסף. הדרך הפשוטה ביותר לזהות את תחילת ה- SS היא ליצור הפרעה חיצונית המופעלת בקצה הנופל של ה- /STROBE. הנתונים תקפים 1.0 לנו לפני הקצה הנופל, כך שכאשר דגמת את הקצה הנופל, אז אתה יודע שאתה יכול לקרוא את הסיכה /DATA1 ולקבל ערך תקף. להלן הקוד ליצירת ההפרעה החיצונית שלך המופעלת בקצה נופל.

voidInitInterrupt (void) {// Setup interrupt BSET (EIMSK, INT0); // מסכת הפרעה חיצונית BSET (EICRA, ISC01); // BCLR קצה נופל (EICRA, ISC00); // נפילת BSET (SREG, 7); // אני קצת ב- SREG}

ב- common.h שאני כולל בכל התוכניות שלי, ניתן למצוא את ההגדרות של BSET ו- BCLR. עיין בקובץ זה אם יש לך שאלות בנוגע להגדרת סיביות. כעת, כאשר ההפרעה מופעלת, אנו רוצים לדגום את /DATA1 (בקוד שלי המוגדר כ- CARD_DATA) ולהגדיר מעט ברישום IO למטרות כלליות. אם אנחנו בביט השביעי, שמור את הרישום כדמות במאגר הגלובלי שלנו. אני משתמש ברשם GPIOR0 מכיוון שזה גישה מהירה. קוד הפסאודו הוא בערך כך:

עצור טיימר 16 סיביות טיימר נקה אם הנתונים נמוכים הגדר BIT = 1 ב- REGISTER הפחתת BIT הגדר דגל כך שלא נדלג על עוד 0 נתונים DATA הוא HIGH Set BIT = 0 ב- REGISTER הפחת BIT אם BIT הוא 0 הוסף בתים למאגר אינדקס תוספות איפוס BIT

אם אתה שואל את עצמך מדוע להוריד במקום להגדיל, זכור שהנתונים הם לאחור, כך שבמקום להקליט את הביטים כשאנחנו מקבלים אותם מ- LSB ל- MSB, אנו שומרים אותם מ- MSB ל- LSB כך שלא נצטרך להפוך את הסיביות לאחור. מאוחר יותר בעת עיבוד הנתונים. אם אתה באמת רוצה, אתה יכול גם להוסיף 0x20 hex כאן, אבל מכיוון שמדובר בערך 5us על פקקים אלה, אני שומר את העיבוד בשגרת שירות ההפרעה למינימום.

ISR (INT0_vect) {StopTimer (); ClearTimer (); אם (! BCHK (PIND, CARD_DATA1)) // נמוך הפוך = 1 {BSET (GPIOR0, ביט); --bit; bDataPresent = 1; } אחרת אם (bDataPresent) {BCLR (GPIOR0, bit); --bit; } אם (ביט <0) {buff [idx] = (char) GPIOR0; ++ idx; ביט = 6; } StartTimer ();} אם אתה תוהה על מה עוסק עסקי התזמון, זה נכלל בשלב הקביעה מתי הכרטיס עזב את הקורא.

שלב 5: קרא את זרם הנתונים

קרא את זרם הנתונים

ובכן, כבר הראיתי לך כיצד לקרוא את הנתונים, מכיוון שהם חלק משגרת השירות להפריע לנו להפריע החיצוני. שיטה חלופית תהיה הצבת דגל ב- ISR, ובלולאה הראשית תסקור את הדגל ויקרא את הנתונים כך, אבל אני מאמין שהצגתי היא נקייה יותר. היו השופטים שלכם ורשמו את שלכם אולם ה- MCU שלכם יאפשר זאת. עם זאת, בואו נעבור לגלות כיצד לזהות כאשר הכרטיס מושך אלביס ויצא מהבניין.

שלב 6: איתור הכרטיס עוזב את הקורא

לזהות מתי כרטיס נעלם

באופן רשמי, אפשר היה לדגום את הסיכה /CARD_PRESENT כדי לראות אם היא שוב נעלמה, אבל לא צריך שום steenkin /CARD_PRESENT ליציאה נוספת של קלט /פלט. כאן נכנסים הטיימרים האלה. בכל פעם שקוראים להפסקה מכיוון שגילינו קצה נופל ב- /STROBE, אנו עוצרים טיימר, מנקים את ערך הטיימר ומתחילים לקרוא. כאשר סיימנו לקרוא אנו מתחילים את הטיימר מחדש. חזור על מודעת בחילה, או עד שהטיימר מגיע לערך מסוים. המשמעות היא שההפסקה האחרונה נקראה ולא נכנסו עוד נתונים, אז אנו מניחים שזהו זה ומתחילים לעבד את הנתונים שאספנו. עבור טיימרים אנו משתמשים ב- TIMER1, כלומר בטיימר 16 סיביות. אני משתמש בתהודה 16 מגה -הרץ חיצונית ל- AVR שלי. אם אתה משתמש בארדואינו, סביר להניח שגם אתה. לכן, בחרתי ערך טרום -מסיר של 1024 כלומר כל (16, 000, 000 /1024) פעמים הטיימר יגדל. כלומר, הוא 'יתקתק' 15, 625 פעמים בשנייה. ה- /CARD_PRESENT יעלה HIGH המציין שהכרטיס השאיר את הקורא כ -150ms לאחר סיבית הנתונים האחרונה. בידיעה זו, פשוט החלטתי לבדוק בערך כל 1/4 משנייה. זה ייראה בערך כך:

(((F_CPU) / PRESCALER) / 4) שמתברר שהוא בסביבות 3900. אם כן, כאשר מונה הטיימר TCNT1 מגיע ל -3900, אז אני יודע שעברו בערך 300ms ואני יכול להסיק בבטחה שהכרטיס עזב את הקורא. קַל

#define PRESCALER 1024#להגדיר CHECK_TIME ((F_CPU / PRESCALER) / 4) // 250 ms#הגדר StartTimer () BSET (TCCR1B, CS10), BSET (TCCR1B, CS12) // 1024 מכשיר טרום מראש#הגדר StopTimer () BCLR (TCCR1B, CS10), BCLR (TCCR1B, CS12) #define ClearTimer () (TCNT1 = 0) ראית ב- ISR היכן הופעל הטיימר, נעצר ומנקה אותו בכל הפרעה. כעת, בלולאה הראשית אנחנו רק בודקים אם מונה הטיימר הגיע לערך היעד שלנו, ואם כן, התחל את עיבוד הנתונים

עבור (;;) {if (TCNT1> = CHECK_TIME) {

StopTimer (); ClearTimer (); ProcessData (); ReadData (); idx = 0; ביט = 6; bDataPresent = 0; memset (& buff, 0, MAX_BUFF_SZ1); }} עכשיו זה בטוח לעבד את הנתונים

קוד מעוצב על ידי

שלב 7: עיבוד הנתונים

לעבד את הנתונים

שלב העיבוד מורכב מ:

• בדיקת SS תקף
• בודק שוויון
• המרה ל- ASCII
• בדיקת ES תקף
• בדיקת LRC

כאן, אני לא טורח לבדוק את השוויון, כיוון שהגדרתי את האפס הזה לאפס. אני גם לא מחשב את LRC עבור הדרכה קטנה זו. זה יהיה משהו שקושחה ממומנת יותר עשויה לרצות לעשות. להלן הקוד לעיבוד הנתונים המבצעים את השלבים שלעיל (ללא האמור לעיל). מצא את זה בתמונה למטה. זה מעיר ודי מסביר את עצמו. הערה מיוחדת בנושא זוגיות ו- ASCII: אני פשוט מנקה את סיביות השוויון (סיביות 7 … כלומר 1 עם 6 אפסים מאחוריו) וכדי להמיר מ"נתוני כרטיס "עליך להוסיף 0x20 לערך. זה בערך הכל.

שלב 8: הצג את הנתונים

הצג את הנתונים

התצוגה עוברת לתוכנית מסוף שכתבתי במיוחד לחיבור ל- AVR באמצעות RS232 או USB. התוכנית נקראת מסוף AVR. שיטת ReadData () היא די מכוערת ואתה מוזמן למצוא פתרון נקי יותר מזה שהבאתי. יש גם פלט של הפונקציה במסוף AVR. הפלט הוא הראשון של כרטיס ביטוח בריאות, והשני הוא של כרטיס VISA. לחץ על בפינה השמאלית העליונה של התמונה ובחר תמונה מקורית או גדולה כדי לראות אותה טוב יותר.

שלב 9: הורדת קוד ועטוף

במדריך זה דנתי בכמה יסודות של קוראי כרטיסים מגנטיים והראיתי לך קוד כלשהו כדי להתחיל בכיוון הנכון בקריאת נתונים מכרטיסים מגנטיים. יש הרבה יותר עבודה שניתן לבצע, כגון קריאה ופענוח המסלול השני, חישוב ה- LRC וחישוב השוויון המוזר על כל בת. קוד המקור המלא זמין להורדה להלן. הוא נכתב ב- AVR Studio 4.17. אני מקווה שנהניתם מההדרכה וכמו תמיד, אני מצפה לכל הערה או הצעה שתהיה לכם. קידוד שמח ו- AVR'ing!