יצירת קובץ STL מסריקת CT - חלק ב'

בחלק א' הצלחנו להגיע למצב של קובץ STL אבל הוא עדיין לא היה מספיק נקי ועדיין לא מוכן להדפסה. בקובץ נשארו שאריות וחלקיקים שאנו רוצים להוריד לפני ההדפסה:

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

אבל אין המון ברירה, אז נשתמש בה צעד אחר צעד...

תחילה נוריד את התכנה מהקישור הזה>>>

לאחר ההתקנה, נפתח את התכנה, נמחק את הקוביה המיותרת במרכז התכנה ונבצע import לקובץ שלנו:

דפדפו לתיקייה הנכונה, בחרו בקובץ שלכם ואל תשכחו ללחוץ בסוף על Import:

תנשמו עמוק:

Zoom in / Zoom out - מבצעים באמצעות גלילת העכבר.
שינוי זווית ההסתכלות - משנים באמצעות לחיצה על Ctrl ותוך כדי על המספרים 1 או 3 שב numpad, כלומר, במקלדת הימנית של המספרים.

באופן אישי, מעדיף לגלול ולשחק כמה שפחות ולעשות בתכנה רק מה שחייבים...

בשלב הבא, נעבור למצב עריכה כדי לטפל במודל שלנו:

כאשר אנחנו במצב עריכה, נלחץ לחיצה אחת בעזרת לחצן ימני בעכבר על אזור גדול במודל אותו אנו רוצים להשאיר. לאחר מכן נלחץ על Ctrl L על מנת לבחור את מה שעליו לחצנו. המטרה שלנו היא לבחור את רוב המודל, ללא השאריות והדברים המיותרים:

כעת, נלחץ על Ctrl I על מנת להפוך בחירה, כלומר, לבחור בכל הדברים המיותרים והלא חשובים...

ולסיום נלחץ על Delete כדי להסיר את החלקים הלא רצויים.

לאחר שהסרנו את כל החלקיקים הלא רצויים, נחזור למצב Object Mode ונראה מה יצא לנו עד כאן:

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

בחלונית ה Repeat נזין ערך בין 20 ל 50 בערך. השאיפה שלנו היא להזין ערך נמוך יחסית כדי לפגוע כמה שפחות בדיוק של המודל:

כעת, אפשר לייצא את הקובץ:

והקובץ מוכן להדפסה...

(בתמונה: הקובץ בתכנת Cura עם תמיכות אוטומטיות של התכנה).

בהצלחה!!

יצירת קובץ STL מסריקת CT - חלק א'

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

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

בתור התחלה, מורידים את תכנת 3D Slicer. 

שימו לב! כרגע (28.01.2018 / 13:10 שעון ישראל) יש תקלה בהורדה של התכנה וניתן להוריד אותה מהקישורים הזמניים באתר. מקווה שבהמשך זה יסתדר. 

לאחר ההורדה וההתקנה נכנסים לתוכנה: 

אז אחרי שיש לנו תכנה שמאפשרת צפייה ועריכה של קבצי CT - נשאר לחפש קבצי CT.... מניסיון - זוהי מלאכה לא קלה: תזכרו שאנחנו צריכים קובץ תלת מימד של CT, לא סתם תמונה. קבצי ה CT נקראים DICOM. אם יש לכם במקרה קובץ DICOM אתם יכולים לנסות ולהשתמש בו. אחרת - ממליץ להשתמש, לפחות בשביל התרגול והלימוד הראשוני, בקבצי הדוגמא של התוכנה. לשם שימוש בקבצי הדוגמא, לחצו על File ואחר כך על Download Sample Data: 

מתוך שלל הדוגמאות, בחרו ב CTBrain:

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

בשלב הבא, נציג את המודל בחלונית הימנית עליונה. נלחץ על Volume Rendering כמו בתמונה:

עכשיו נשאר לנו ללחוץ על העין הקטנה ולשחק עם סליידר של ה shift כדי להגיע למצב הנכון מבחינתנו: להציג את עצמות הגולגולת:

כעת, נעבור למצב עריכה ונעבד עיבוד אחרון את המודל לפני היצוא שלו:

נבחר OK בחלונית שתפתח לנו:

ונבחר בצבע Bone, עצם:

לאחר הבחירה בצבע הנכון, ניגש לעיבוד של המודל. נלחץ על Threshold Effect ונכוון את כמות ה"עצם" הנכונה:

אל תשכחו ללחוץ על Apply בסיום הפעולה. כעת, אנו מוכנים לעבור לשלב הבא של הלבשת האפקט על המודל:

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

השלב הבא הוא יצוא של מודל STL:

לחצו על Save ובחלונית שתפתח בחרו באפשרות STL כמתואר בתמונה. בחרו את שם הקובץ ואת המקום בו תרצו לשמור את הקובץ ולחצו Save.

כעת הקובץ שלכם נשמר במקום בו בחרתם שהוא ישמר אך הקובץ אינו מוכן להדפסה עדיין. הוא מכיל שברי חלקיקים מרחפים ודברים שלא תרצו להדפיס (שימו לב למשל לחלקיקים הקטנים שמסומנים בחץ האדום):

אז מה שנשאר לנו לעשות זה רק לנקות קצת את הקובץ ועל כך בפעם הבאה...


מעבר ליצירת קובץ STL מסריקת CT - חלק ב'

חיישני רוורס

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

מוכנים?

רכיבים:

• לוח ארדואינו
• מטריצה
• כמה חוטים 
• זמזם (באזזר)
• חיישן מרחק אולטראסוני
• נגד 100Ω (עובד גם עם 220Ω אבל אם יש לכם 100Ω בזמינות - תשתמשו בו). 

שימו לב שאת החיישן האולטראסוני אפשר לחבר למטריצה (ואז להשתמש בחוטים זכר-זכר) או לחבר כמו בציור (ואז תאלצו להשתמש בזכר-נקבה). 

לאחר שהמעגל מורכב - נשאר לנו רק להעלות את הקוד: 

#include <Wire.h> #include <Wire.h> const int trigPin = 9; const int echoPin = 10; int speakerPin = 12; long duration; int distance; void setup() { pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); Serial.begin(9600); delay(500); pinMode(2,OUTPUT); } void loop() { digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); duration = pulseIn(echoPin, HIGH); distance= duration*0.034/2; Serial.print("Distance: "); Serial.println(distance); if (distance>=50) { noTone (speakerPin); } else{ if (distance>=35) { tone(speakerPin, 500); delay(300); noTone(speakerPin); delay(300); } else { if (distance>=25) { tone(speakerPin, 500); delay(150); noTone(speakerPin); delay(150); } else{ if (distance>=15) { tone(speakerPin, 500); delay(50); noTone(speakerPin); delay(50); noTone(speakerPin); } else{ if (distance>=10) { tone(speakerPin, 500); digitalWrite(2,HIGH); } } } } } }

כעת תוכלו לבחון את הפעולה של חיישני הרוורס ובקביל, תוכלו לפתוח מסך סיריאלי כדי לראות את המרחק שהחיישן מודד.

בהצלחה!!

מערכת אבטחה לבית מבוססת SMS

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

רכיבים:

• לוח ארדואינו
• רכיב Sim800L
• כרטיס Sim
• חיישן תנועה PIR
• להשלמת המערכת - מצלמת אינטרנט פשוטה. 

מוכנים? 

תחילה מרכיבים את המעגל: 

• את חיבור ה VCC ברכיב ה Sim800L - מחברים ל 5V בארדואינו
• את חיבור ה GND ברכיב ה Sim800L - מחברים ל GND בארדואינו
• את חיבור ה RXD ברכיב ה Sim800L - מחברים ליציאה מספר 8 בארדואינו 
• את חיבור ה TXD ברכיב ה Sim800L - מחברים ליציאה מספר 9 בארדואינו.
• את חיבור ה GND ברכיב ה PIR - מחברים ל GND בארדואינו
• את חיבור ה VCC ברכיב ה PIR - מחברים ל 3.3V בארדואינו (לא לחבר ל 5V - ראה הערה בעוד שתי שורות..). 
• את חיבור ה OUT ברכיב ה PIR - מחברים ליציאה מספר 2 בארדואינו. 

שימו לב!! כאשר ניסיתי לחבר את ה VCC ברכיב ה PIR דרך מטריצה אל ה 5V בארדואינו (כלומר, לחבר גם את ה PIR וגם את ה Sim800L אל המטריצה ולחבר את המטריצה אל הארדואינו) - המכשיר לא שלח SMS. 

כאשר בדקתי באמצעות המסך הסיריאלי, הבנתי שחיישן התנועה (PIR) עובד מצוין אולם ה Sim800L לא מקבל מספיק מתח. כאשר העברתי את ה PIR לחיבור 3.3V - הכל הסתדר. 

(אגב, לקח לי זמן למצוא את התמונה של החיישן PIR בתכנת ה fritzing עד שמצאתי אותו כאן. תודה!) 

אחרי שהמעגל מוכן, אפשר להעלות את הקוד. ראשית מורידים את הספריה GPRS מכאן. 

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

#include <gprs.h> #include <SoftwareSerial.h> int sensor = 2; int state = LOW; int val = 0; GPRS gprs; void setup() { pinMode(sensor, INPUT); Serial.begin(9600); Serial.println("GPRS - Send SMS Test ..."); gprs.preInit(); delay(1000); while(0 != gprs.init()) { delay(1000); Serial.print("init error\r\n"); } Serial.println("Init success, start to send SMS message..."); gprs.sendSMS("+972**********","Ready"); } void loop() { val = digitalRead(sensor); if (val == HIGH) { if (state == LOW) { Serial.println("Motion detected!"); gprs.sendSMS("+972**********","Motion detected!"); state = HIGH; } } else { if (state == HIGH){ Serial.println("Motion stopped!"); gprs.sendSMS("+972**********","Motion stopped!"); state = LOW; } } }


שימו לב שהחיישן ניתן לכיוון פיזי. שחקו מעט עם הכיוון שלו עד שתגיעו לרגישות הרצויה.

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

אפשר להשתמש במצלמת רשת פשוטה (כמו זו שאני השתמשתי בה) או במצלמה המובנית של הלפטופ.

לצורך ההתחברות, הורדתי למחשב את אפליקציית AT Home video streame והתקנתי אותה. לאחר מכן, מחנות האפליקציות של גוגל - הורדתי את האפליקציה המתאימה עבור הטלפון הנייד. יש גם אפליקציה תואמת אפל (לא בדקתי).

בשלב הבא, פותחים את התכנה על גבי המחשב ומבקשים ממנה לייצר קוד QR עבור ההתחברות (ראו תמונה למטה). התכנה מייצרת קוד QR אותו יש לסרוק בעזרת הטלפון. זהו!! מצלמת האבטחה שלכם עובדת!!

מטעמים של פרטיות, צינזרתי מעט את הקוד...

המערכת מוכנה לפעולה:

בהצלחה!!

שליחת SMS באמצעות ארדואינו

איך שולחים SMS באמצעות ארדואינו?

רכיבים: 

• לוח ארדואינו
• מטריצה (לא חובה. תלוי בסוג החוטים שיש ברשותך).  
• Sim800L
• כרטיס Sim
• כמה חוטים.. 

מחברים את החוטים: 

1. את חיבור ה VCC ברכיב ה Sim800L - מחברים ל 5V בארדואינו
2. את חיבור ה GND ברכיב ה Sim800L - מחברים ל GND בארדואינו
3. את חיבור ה RXD ברכיב ה Sim800L - מחברים ליציאה מספר 8 בארדואינו 
4. את חיבור ה TXD ברכיב ה Sim800L - מחברים ליציאה מספר 9 בארדואינו. 

במציאות זה נראה בערך ככה:

מורידים את הספריה מכאן. מחלצים את הקבצים ומניחים במקום. (אצלי זו הכתובת: C:\Program Files (x86)\Arduino\libraries). 

כעת אפשר להעלות את הקוד: 

נכנסים לדוגמאות של הספריה ומעלים את הקוד GPRS_SendSMS. לנוחיותכם מצרף לכם את הקוד כאן: 

#include <gprs.h> #include <SoftwareSerial.h> GPRS gprs; void setup() { Serial.begin(9600); while(!Serial); Serial.println("GPRS - Send SMS Test ..."); gprs.preInit(); delay(1000); while(0 != gprs.init()) { delay(1000); Serial.print("init error\r\n"); } Serial.println("Init success, start to send SMS message..."); gprs.sendSMS("***********","hello,world"); } void loop() {}

אל תשכחו לרשום את המספר שלכם, אליו אתם רוצים שהארדואינו ישלח את ה SMS, במקום הכוכביות.

כעת פתחו את המסך הסיריאלי:

על המסך תראו שהארדואינו מתחיל במשלוח ה SMS.

אחרי כמה שניות תוכלו לראות את ה SMS בטלפון שלכם:

וזה עובד!


בהצלחה!

איך מייצאים פרויקט מ Tinkercad?

אם סיימתם את הפרויקט ב Tinkercad, הגיע הזמן לייצא אותו ולשלוח להדפסה. איך עושים את זה? פשוט מאד:

1. בשלב הראשון מוודאים שיש לנו על משטח העבודה רק דברים שאנו רוצים לייצא והם חלק מהקובץ. אם נשארו דברים לא קשורים - מוחקים אותם (אפשר גם ללא מחיקה אבל בחרתי באפשרות ההסבר הקלה).

2. אחרי שמחקתם הכל ונשארתם רק עם המודל - תצטרכו לאחד הכל לקבוצה אחת: סמנו את כל הצורות והחלקים ולחצו על כפתור ה Group.

3. עכשיו אנחנו מוכנים לייצוא: לחצו על כפתור ה Export שמופיע מצד ימין למעלה:

4. יפתח מסך קטן ובו נבחר באפשרות Stl:

5. לאחר שניות ספורות תתחיל הורדה אוטומטית של הקובץ לתיקיית ההורדות (Downloads) של המחשב תוך כדי סימון ההורדה בצד ימין למטה של המסך (או שמאל לדוברי אנגלית..). יתכן שהמחשב יפתח לכם חלון הורדה - אם כן, בחרו היכן לשמור את הקובץ (ותזכרו איפה שמרתם אותו...).

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

בהצלחה!!

חיישן אולטראסוני

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

כדי להשתמש בחיישן צריך:

• לוח ארדואינו
• מטריצה (לא חובה, תלוי איזה חוטים יש לכם)
• מספר חוטים
• חיישן אולטראסוני

מתחילים להרכיב את המעגל:

מעלים את הקוד:

#include <Wire.h> const int trigPin = 9; const int echoPin = 10; long duration; int distance; void setup() { pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); Serial.begin(9600); delay(2000); } void loop() { digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); duration = pulseIn(echoPin, HIGH); distance= duration*0.034/2; Serial.print("Distance: "); Serial.println(distance); }

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

ו... משימה קטנה: בנו "מובילאיי": כאשר המרחק קטן מ 30 ס"מ - תדלק נורה... בהצלחה!!


עדכון: ישועה בנה את ה"מובילאיי" והוא בדרך ל Exit ;-)

בינתיים הוא שלח לי את הקוד הבא:

#include <Wire.h> const int trigPin = 9; const int echoPin = 10; long duration; int distance; void setup() { pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); Serial.begin(9600); delay(500); pinMode(2,OUTPUT); } void loop() { digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); duration = pulseIn(echoPin, HIGH); distance= duration*0.034/2; if (distance<=30) { digitalWrite(2,HIGH); } else { digitalWrite(2,LOW); } Serial.print("Distance: "); Serial.println(distance); }


לאחר שעדכנתם את הקוד, תצטרכו כמובן לעדכן גם את התרשים ולהוסיף לתרשים שלכם נורה:

נחבר נורת לד דרך נגד ליציאה מספר 2 בארדואינו. נחבר את הרגל הקצרה של הנורה ל GND.

תודה ישועה!

שימו לב כמובן להבדל בין המובילאיי למערכת שבנינו: המערכת שבנינו מזהה מרחק, המובילאיי מזהה זמן עד להתנגשות שמחושב על פי מהירות ביחס למרחק (אתם מוזמנים לתכנן מערכת כזאת ולפרסם כאן בתגובות...). אגב, המערכת שיהושע בנה עובדת בדיוק כמו חיישני רוורס לרכב.

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

וכמה משימות קטנות:

1. ערכו שינוי קטן בקוד כך שהנורה תדלק רק כאשר המרחק קטן מ 50 ס"מ.

2. נסו לגרום לנורה לדלוק כאשר המרחק גדול מ 50 ס"מ. כאשר המרחק קטן מ 50 ס"מ הנורה תהיה כבויה. 

3. נסו להוסיף נורה חדשה למעגל: כאשר המרחק קטן מ 50 ס"מ תדלק נורה אחת, כאשר המרחק קטן מ 30 ס"מ ידלקו שתי הנורות. 

בהצלחה!

ואגב, את המשפט הבא אני כותב רק כדי שתמצאו את האולטראסוני גם אם כתבתם אולטרה סוני או אולטרסוני או סתם כך: אולטרא סוני...

קורא טביעות אצבע וארדואינו

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

1. הכנסת טביעות אצבע למאגר הקורא
2. בדיקה האם הקורא מכיר טביעה מסוימת

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

מה צריך בשביל לעבוד?

• קורא טביעות אצבע
• לוח ארדואינו
• 4 חוטים 
• כמה כלים: חושף חוטים, שרוול שרינק / איזולירבנד (לא חובה אבל כדאי). 

קורא טביעות האצבע שקניתי הגיע עם 6 חוטים אדומים: מה מהם הוא ה TX? ומה ה RX? איפה ה GND? ומאיפה הקורא מקבל מתח? 

לאחר חיפושים, הגעתי לפורום הזה ושם מצאתי את התרשים הבא: 

אז אחרי שהצלחנו להבין מהו כל חוט - נחבר את החוטים: 

• נחבר את ה VCC בקורא טביעות האצבע ל 3.3V בארדואינו
• נחבר את ה GND בקורא טביעות האצבע ל GND בארדואינו
• נחבר את ה TX בקורא טביעות האצבע ליציאה מספר 2 בארדואינו
• נחבר את ה RX בקורא טביעות האצבע ליציאה מספר 3 בארדואינו

שימו לב ששני חוטים נותרים ללא חיבור.

ועכשיו? 

פתחו את תכנת הארדואינו, הכנסו למנהל הספריות והורידו את ספריית ה fingerprint  של Adafruit. אפשר להוריד את הספריה גם מכאן, לחלץ את הקבצים ולשים אותם בתיקיית ה libraries שבתיקיית הארדואינו. 

לאחר מכן, בתכנת הארדואינו פתחו את "קובץ" >> "דוגמאות" >> Adafruit fingerprint sensor library >> ואז לבחור ב enroll. 

לנוחיותכם, העליתי את הקוד גם לכאן: 

#include <Adafruit_Fingerprint.h> #include <SoftwareSerial.h> SoftwareSerial mySerial(2, 3); Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial); uint8_t id; void setup() { Serial.begin(9600); delay(100); Serial.println("\n\nAdafruit Fingerprint sensor enrollment"); finger.begin(57600); if (finger.verifyPassword()) { Serial.println("Found fingerprint sensor!"); } else { Serial.println("Did not find fingerprint sensor :("); while (1) { delay(1); } } } uint8_t readnumber(void) { uint8_t num = 0; while (num == 0) { while (! Serial.available()); num = Serial.parseInt(); } return num; } void loop() { Serial.println("Ready to enroll a fingerprint!"); Serial.println("Please type in the ID # (from 1 to 127) you want to save this finger as..."); id = readnumber(); if (id == 0) {! return; } Serial.print("Enrolling ID #"); Serial.println(id); while (! getFingerprintEnroll() ); } uint8_t getFingerprintEnroll() { int p = -1; Serial.print("Waiting for valid finger to enroll as #"); Serial.println(id); while (p != FINGERPRINT_OK) { p = finger.getImage(); switch (p) { case FINGERPRINT_OK: Serial.println("Image taken"); break; case FINGERPRINT_NOFINGER: Serial.println("."); break; case FINGERPRINT_PACKETRECIEVEERR: Serial.println("Communication error"); break; case FINGERPRINT_IMAGEFAIL: Serial.println("Imaging error"); break; default: Serial.println("Unknown error"); break; } } p = finger.image2Tz(1); switch (p) { case FINGERPRINT_OK: Serial.println("Image converted"); break; case FINGERPRINT_IMAGEMESS: Serial.println("Image too messy"); return p; case FINGERPRINT_PACKETRECIEVEERR: Serial.println("Communication error"); return p; case FINGERPRINT_FEATUREFAIL: Serial.println("Could not find fingerprint features"); return p; case FINGERPRINT_INVALIDIMAGE: Serial.println("Could not find fingerprint features"); return p; default: Serial.println("Unknown error"); return p; } Serial.println("Remove finger"); delay(2000); p = 0; while (p != FINGERPRINT_NOFINGER) { p = finger.getImage(); } Serial.print("ID "); Serial.println(id); p = -1; Serial.println("Place same finger again"); while (p != FINGERPRINT_OK) { p = finger.getImage(); switch (p) { case FINGERPRINT_OK: Serial.println("Image taken"); break; case FINGERPRINT_NOFINGER: Serial.print("."); break; case FINGERPRINT_PACKETRECIEVEERR: Serial.println("Communication error"); break; case FINGERPRINT_IMAGEFAIL: Serial.println("Imaging error"); break; default: Serial.println("Unknown error"); break; } } p = finger.image2Tz(2); switch (p) { case FINGERPRINT_OK: Serial.println("Image converted"); break; case FINGERPRINT_IMAGEMESS: Serial.println("Image too messy"); return p; case FINGERPRINT_PACKETRECIEVEERR: Serial.println("Communication error"); return p; case FINGERPRINT_FEATUREFAIL: Serial.println("Could not find fingerprint features"); return p; case FINGERPRINT_INVALIDIMAGE: Serial.println("Could not find fingerprint features"); return p; default: Serial.println("Unknown error"); return p; } Serial.print("Creating model for #"); Serial.println(id); p = finger.createModel(); if (p == FINGERPRINT_OK) { Serial.println("Prints matched!"); } else if (p == FINGERPRINT_PACKETRECIEVEERR) { Serial.println("Communication error"); return p; } else if (p == FINGERPRINT_ENROLLMISMATCH) { Serial.println("Fingerprints did not match"); return p; } else { Serial.println("Unknown error"); return p; } Serial.print("ID "); Serial.println(id); p = finger.storeModel(id); if (p == FINGERPRINT_OK) { Serial.println("Stored!"); } else if (p == FINGERPRINT_PACKETRECIEVEERR) { Serial.println("Communication error"); return p; } else if (p == FINGERPRINT_BADLOCATION) { Serial.println("Could not store in that location"); return p; } else if (p == FINGERPRINT_FLASHERR) { Serial.println("Error writing to flash"); return p; } else { Serial.println("Unknown error"); return p; } }

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

באופן זה, נבנה את המאגר הביומטרי האישי שלנו של טביעות האצבע אותן נרצה שהסורק יציג.

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

החיבורים הם אותם החיבורים בדיוק אך יש להעלות קוד חדש. את הקוד החדש ניתן למצוא בדוגמאות תחת השם fingerprint:

#include <Adafruit_Fingerprint.h> #include <SoftwareSerial.h> SoftwareSerial mySerial(2, 3); Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial); void setup() { Serial.begin(9600); delay(100); Serial.println("\n\nAdafruit finger detect test"); finger.begin(57600); if (finger.verifyPassword()) { Serial.println("Found fingerprint sensor!"); } else { Serial.println("Did not find fingerprint sensor :("); while (1) { delay(1); } } Serial.println("Waiting for valid finger..."); } void loop { getFingerprintIDez(); delay(50); } uint8_t getFingerprintID() { uint8_t p = finger.getImage(); switch (p) { case FINGERPRINT_OK: Serial.println("Image taken"); break; case FINGERPRINT_NOFINGER: Serial.println("No finger detected"); return p; case FINGERPRINT_PACKETRECIEVEERR: Serial.println("Communication error"); return p; case FINGERPRINT_IMAGEFAIL: Serial.println("Imaging error"); return p; default: Serial.println("Unknown error"); return p; } p = finger.image2Tz(); switch (p) { case FINGERPRINT_OK: Serial.println("Image converted"); break; case FINGERPRINT_IMAGEMESS: Serial.println("Image too messy"); return p; case FINGERPRINT_PACKETRECIEVEERR: Serial.println("Communication error"); return p; case FINGERPRINT_FEATUREFAIL: Serial.println("Could not find fingerprint features"); return p; case FINGERPRINT_INVALIDIMAGE: Serial.println("Could not find fingerprint features"); return p; default: Serial.println("Unknown error"); return p; } p = finger.fingerFastSearch(); if (p == FINGERPRINT_OK) { Serial.println("Found a print match!"); } else if (p == FINGERPRINT_PACKETRECIEVEERR) { Serial.println("Communication error"); return p; } else if (p == FINGERPRINT_NOTFOUND) { Serial.println("Did not find a match"); return p; } else { Serial.println("Unknown error"); return p; } Serial.print("Found ID #"); Serial.print(finger.fingerID); Serial.print(" with confidence of "); Serial.println(finger.confidence); return finger.fingerID; } int getFingerprintIDez() { uint8_t p = finger.getImage(); if (p != FINGERPRINT_OK) return -1; p = finger.image2Tz(); if (p != FINGERPRINT_OK) return -1; p = finger.fingerFastSearch(); if (p != FINGERPRINT_OK) return -1; Serial.print("Found ID #"); Serial.print(finger.fingerID); Serial.print(" with confidence of "); Serial.println(finger.confidence); return finger.fingerID; }

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


בהצלחה!