Makey Makey

Makey Makey הוא לוח שהופך כל פעולה במחשב לנחמדה יותר או שמא נאמר - מוזרה יותר...

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

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

דוגמא? בבקשה:

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

הלוח הבסיסי והמוכר הוא הלוח הזה:

אל הלוח מחברים חוטים עם "תנינים":

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

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

תראו למשל את הנגינה בפסנתר האנושי:

שימו לב! בעזרת תכנת סקרטצ' - Scratch (או תכנות אחרות) תוכלו ליצור משחק / חידון או אפליקציה שפועלת בעזרת החיצים. לאחר מכן, תוכלו לחבר אליה את Makey Makey וכך לעבוד עם בקרי משחק מיוחדים שבניתם המתאימים בדיוק למשחק שבניתם בסקרטצ'!

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

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

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

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

כך נראה ה shield של ה Makey Makey כאשר הוא כבר מחובר לארדואינו אונו.

בקיצור - ה Makey Makey זה עולם שלם עם אפשרויות מגוונות מאד ורק פתחנו אותו קצת והשמיים הם הגבול... 

גלי מוח

לבדוק גלי מוח בעזרת הארדואינו? לא מסובך אבל דורש את המשחק MindFlex בהישג יד. אז אם יש לכם - אתם מוזמנים לנסות.

רכיבים:

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

מתחילים עם פירוק החלק השמאלי של רצועת הראש - החלק שכולל את כפתור ההדלקה ואת מד הדופק לאוזן. לא החלק של הסוללות: 

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

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

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

ומה נשאר?

הקוד לארדואינו דורש ספריית Brain אותה ניתן להוריד מכאן >>>

לאחר שהורדתם את הספריה - תוכלו להיכנס לדוגמאות שלה, דרך הארדואינו ולהוריד את הקוד - Brain Serial Test. לנוחיותכם - העתקתי אותו גם לכאן:

#include <Brain.h> Brain brain(Serial); void setup() { Serial.begin(9600); } void loop() { if (brain.update()) { Serial.println(brain.readErrors()); Serial.println(brain.readCSV()); } }


כעת, חברו את חוט ה T לחיבור ה RX בארדואינו ואת חיבור ה GND לחיבור ה GND בארדואינו.

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

כעת, הורידו את הקבצים של ה Processing מכאן. אם אין לכם Processing תוכלו להיעזר במדריך שהכנו לכם.

פתחו את התיקייה, חלצו את הקבצים ובתוך תיקיית BrainGrapher בחרו בקובץ BrainGrapher. וודאו שהארדואינו מחובר למחשב בכבל ה USB, ה MindFlex דולק ורק לאחר מכן, לחצו על כפתור ה Run ב Processing.
על גבי המסך של המחשב אתם אמורים לראות את הגרף של גלי המוח, כלומר, בהנחה שהנחתם את רצועת הראש במקומה, כולל חיישן הדופק על תנוך האוזן. אם הכל הלך כשורה עד לכאן זה אמור להראות בערך כך:

בהצלחה!

חדר סימולציה - ADHD

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

• ארדואינו לאונרדו
• ארדואינו אונו
• מסך LCD
• לחצן
• 2 נגדים של 10KΩ
• ריליי (relay) כפול
• פוטנציומטר
• מטריצות 
• המון חוטים... 
• מאוורר
• פרוז'קטור

נתחיל בבניה באופן מסודר ושיטתי על פי התרשים הבא: 

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

התוצאה הסופית נראית בערך כך: 

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

לאחר שסיימנו מעלים את הקוד. שימו לב שיש לנו שני קודים להעלות - קוד לארדואינו לאונרדו וקוד לארדואינו אונו. 

קוד לארדואינו לאונרדו: 

#include <Wire.h> #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); int uno = 8; int led = 13; int stateled =LOW; int button = 10; int virt = 0; int hours = 0; int minutes = 0; int seconds = 10; int range = 12; int responseDelay = 5; int threshold = range / 4; int center = range / 2; #include "Keyboard.h" #include "Mouse.h" char ctrlKey = 128; char altKey = 134; char tabKey = 179; char shiftKey = 133; char spaceKey = 32; char minusKey = 45; char plusKey = 43; const int upButton = 2; const int downButton = 3; const int leftButton = 4; const int rightButton = 5; const int mouseButton = 6; void setup() { pinMode(button, INPUT); pinMode(upButton, INPUT); pinMode(downButton, INPUT); pinMode(leftButton, INPUT); pinMode(rightButton, INPUT); pinMode(mouseButton, INPUT); lcd.begin(16, 2); Serial.begin(9600); Keyboard.begin(); pinMode(button, INPUT); pinMode(uno, OUTPUT); pinMode(led, OUTPUT); lcd.clear(); lcd.setCursor(0,0); lcd.print("press the button"); Serial.println("Hello! press the button"); } void trigger(){ lcd.clear(); lcd.setCursor(0,0); lcd.print("Thanks"); lcd.setCursor(4,1); lcd.print("00:00:00"); Serial.println("The End"); int xReading = 1023; int yReading = 512; for (int i=0; i<2000; i++){ Mouse.move(xReading, yReading, 0); delay(responseDelay); } Mouse.press(); Mouse.release(); for (int i =0; i<8;i++){ Keyboard.press(shiftKey); Keyboard.press(tabKey); Keyboard.releaseAll(); } Keyboard.press(spaceKey); Keyboard.releaseAll(); Mouse.end(); hours = 0; minutes = 0; seconds = -1; lcd.clear(); lcd.setCursor(0,0); lcd.print("press the button"); delay(1000); } void stepdown() { while (hours > 0 || minutes > 0|| seconds >= 0) { digitalWrite (uno, HIGH); (hours < 10) ? Serial.print("0") : NULL; lcd.setCursor(4,1); (hours < 10) ? lcd.print("0") : NULL; Serial.print(hours); lcd.print(hours); Serial.print(":"); lcd.print(":"); (minutes < 10) ? Serial.print("0") : NULL; (minutes < 10) ? lcd.print("0") : NULL; Serial.print(minutes); lcd.print(minutes); Serial.print(":"); lcd.print(":"); (seconds < 10) ? Serial.print("0") : NULL; (seconds < 10) ? lcd.print("0") : NULL; Serial.println(seconds); lcd.print(seconds); delay(1000); if (seconds > 0) { seconds -= 1; } else { if (minutes > 0) { seconds = 59; minutes -= 1; } else { if (hours > 0) { seconds = 59; minutes = 59; hours -= 1; } else { digitalWrite (uno,LOW); trigger(); } }}} } void loop() { virt=digitalRead(button); if(virt == 0) { digitalWrite(led, HIGH); delay(500); digitalWrite(led, LOW); delay(500); } else{ virt=1; if(virt==1){ virt=0; minutes=5 seconds=30; Mouse.begin(); delay(100); digitalWrite(uno, HIGH); lcd.clear(); lcd.setCursor(0,0); Serial.println("Timer on"); lcd.print("Timer on"); delay(1000); stepdown(); } } }


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

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

int relay1 =7; int relay2 =9; int leonardo =8; void setup() { pinMode(relay1, OUTPUT); pinMode(relay2, OUTPUT); pinMode(leonardo, INPUT); } void loop() { if(digitalRead(leonardo)==HIGH){ int random1=random(200,3000); int random2=random(200,3000); digitalWrite(relay1, HIGH); delay(random1); digitalWrite(relay1, LOW); delay(random2); digitalWrite(relay2, HIGH); delay(random2); digitalWrite(relay2, LOW); delay(random2); } }

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

וכמה דגשים לסיום:

1. הארדואינו לאונרדו חייב להיות מחובר בסופו של דבר למחשב!

2. כאשר חיברתי את הארדואינו לאונרדו והארדואינו אונו יחד למחשב - המחשב התריע בפני "זלילה" מרובה מדי של חשמל מיציאות ה USB. יתכן שזה בגלל החיבור למחשב "גרוטאה" מכיוון שבמחשב האישי שלי זה עבר ללא בעיות. השתמשנו במחשב ישן במיוחד מכיוון שרצינו להעמיד את הדברים במשך חודש פתוחים לציבור הרחב ללא השגחה...

3. בסופו של דבר חיברנו את הארדואינו אונו לחשמל ביתי בעזרת שנאי והמערכת כולה עבדה ללא הפרעות מיוחדות וללא תחזוקה במשך חודש ימים!

בהצלחה!!

(בתמונה שצולמה מחלון חדר הסימולציה: היועץ המקצועי לשר המדע, זהר טל, מתנסה בשימוש במערכת)

ארדואינו & leap motion

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

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

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

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


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

איך מתקינים את ה Leap motion?

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

ועכשיו לשלב הבא - חיבור הארדואינו ל Leap motion:

זה לא כל כך מסובך ואפילו די פשוט למי שבעניינים אבל בהחלט לא מתאים למתחילים שלא יודעים להוריד ספריות או למי שלא עבדו אף פעם עם Processing.

רכיבים:

• לוח ארדואינו
• נורת לד
• Leap motion

1. מורידים Processing

2. מורידים את הספריה הרצויה: נכנסים ל Processing - 

• לוחצים על Sketch 
• Import Library 
• Add Library

כמו בתמונה הבאה:

בוחרים בספריה leapmotion for processing  ומוסיפים אותה.

3. שימו לב שאנו צריכים להעלות קוד ל Processing  וקוד מתאים לארדואינו. נעלה ל Processing  את הקוד:

import processing.serial.*; import de.voidplus.leapmotion.*; LeapMotion leap; Serial myPort; void setup() { leap = new LeapMotion(this); println(Serial.list()); myPort = new Serial(this,Serial.list()[0], 9600); } void draw() { background(0); for (Hand hand : leap.getHands()) { pushMatrix(); float handSize = hand.getSphereRadius(); int handSize2 = int(handSize); myPort.write(handSize2); println(handSize2); popMatrix(); } }


ולאחר מכן נעלה לארדואינו את הקוד:

int val; int led = 13; int brightness = 0; int fadeAmount = 5; void setup() { Serial.begin(9600); pinMode(led, OUTPUT); } void loop() { if (Serial.available() == '\n') { val= Serial.read(); if (val<60) { digitalWrite(led,LOW); } if (val>60) { digitalWrite(led,HIGH); } } }


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

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

ומה עוד?

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


(קרדיט לאתר מקור. חיפשתי המון פרויקטים פשוטים שמתאימים לתחילת עבודה ב Leap motion ושמחתי למצוא כאן משהו פשוט ועובד...)

ארדואינו לאונרדו / Arduino Leonardo

ארדואינו לאונרדו הוא לוח ארדואינו עם חיבורים זהים לארדואינו אונו (UNO) ולמעשה ניתן להעלות את הקוד שהכנתם לאונו על גבי הארדואינו לאונרדו (לא בדקתי את כל הקודים אבל לא אמורה להיות בעיה). אז מה מיוחד בלאונרדו?

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

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

(ארדואינו לאונרדו - אותם יציאות, כבל ה USB שונה: כבל ה USB B הוחלף ב USB מסוג מיקרו)

ואם לא הבנתם לגמרי מה אפשר לעשות איתו - הנה דוגמא קטנה: 

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

(התערוכה של בית ספר 'דעת' - ברקע מצד ימין ניתן לראות את חדר הסימולציה מבחוץ) 

לצורך הפרויקט, השתמשו התלמידים בארדואינו אונו מחובר לריליי שיוצר את ההפרעות: מדליק ומכבה באקראיות פרוז'קטור ומאוורר. מי שמפעיל את הארדואינו אונו הוא ארדואינו לאונרדו שמונה 5:30 דקות כאשר בסיומם הוא מכבה את הארדואינו אונו (וליתר דיוק - גורם לארדואינו להפסיק את ההפרעות). באותם 5:30 דקות האדם שנמצא בחדר הסימולציה אמור לענות על מבחן בנושא המוח. המבחן בנוי כטופס גוגל (Google Form) וכל התשובות נמצאות בקטע הקריאה כך שלמעשה המבחן לא בודק ידע או זיכרון אלא רק ריכוז. 

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

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

תראו קטע קטן מהקוד: 

int xReading = 1023; int yReading = 512; for (int i=0; i<2000; i++){ Mouse.move(xReading, yReading, 0); delay(responseDelay); } Mouse.press(); Mouse.release(); for (int i =0; i<8;i++){ Keyboard.press(shiftKey); Keyboard.press(tabKey); Keyboard.releaseAll(); } Keyboard.press(spaceKey); Keyboard.releaseAll(); Mouse.end();

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

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

כאשר נלחץ בעזרת העכבר במקום "ניטרלי" בעמוד, נוכל לחשב את מספר לחיצות ה Tab - במקרה שלנו - 8 לחיצות בדיוק. לכן, העכבר זז 2000 פעמים לצד שמאל, לוחץ לחיצה (Mouse.press) ואחר כך אנחנו מתחילים לספור 8 טאבים עד למצב הרצוי שאחריו מקש הרווח (spaca) יתן את הלחיצה על ה"שלח" והטופס ישלח..

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

כך נראית המערכת לפני החיבור למאוורר ולפרוז'קטור...:

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

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

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

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

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

ולסיום - תודה רבה לשמוליק שוורץ על העזרה עם הקוד של חדר הסימולציה!

עדכון: תוכלו לראות כאן את התרשים המלא ואת הקוד להרכבת המערכת. 

שמירת תכנית scratch כתכנית עצמאית

אז אחרי שעבדנו ועמלנו והשתדלנו - יש לנו תכנית מוכנה. ומה עכשיו? 

ברור שאנחנו רוצים שהתכנית תהיה עצמאית ונוכל להיכנס אליה גם ללא scratch. השלבים הבאים עשויים להיות מעט מסובכים אבל ננסה צעד אחר צעד להסביר אותם: 

1. שמירה של הקובץ מה scratch - שמירה של הקובץ מה scratch תתבצע על ידי לחיצה על "קובץ" ולאחר מכן על "שמור". כעת, הקובץ נמצא (אני מקווה שאתם יודעים היכן...) ואנחנו עוברים לשלב הבא. 

2. המרה של הקובץ מפורמט SB2 לפורמט SWF - זהו שלב ביניים ולצורך כך השתמשתי בתכנית הענן junebeetle. נכנסים לקישור ומעלים את הקובץ שלכם לתכנת הענן על ידי לחיצה על open scratch file

בוחרים את הקובץ שלכם ואז לוחצים על convert to swf:

כעת שימו לב לתת לקובץ סיומת של swf, לדוגמא: example.swf

3. היכנסו לקישור הזה והורידו את גרסת הניסיון חינם ל 30 ימים.  התכנה הזו אמורה לעשות את ההמרה בין swf ל exe. 

4. פתחו את התכנה והעלו את הקובץ שלכם: 

5. לאחר מכן, תתבקשו לקבוע היכן לשמור את הקובץ לאחר ההמרה: 

6. ואם הכל מוכן - תוכלו להמיר את הקובץ על ידי לחיצה על convert: 

זהו - התכנית שלכם מוכנה!

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

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

בהצלחה!! 

עבודה עם scratch / דביר

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

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

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

כעת ישלח אליכם עוד מייל ובו כמה קישורים. לחצו על "learn how to make a projekt" או לחצו כאן לתחילת ההתנסות בתכנה.

נתחיל?...

התוכנה נראית ככה:

כפי שאתם רואים יש כאן כמה חלקים עיקריים:

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

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


ישנם סוגים שונים של פקודות כאשר הפקודות העיקריות הן: 

1. תנועה - שליטה בתנועה של הדמות. 
2. מראה - שליטה במראה של הדמות (כולל בועות דיבור, רקע, שינוי תלבושת, וכדומה)
3. צליל - שליטה בצלילים המושמעים בתוכנית.
4. אירועים - התייחסות של התוכנה לקלט שמתקבל (לחיצה על עכבר\מקש וכדומה).
5. בקרה - התניות ("אם-אז"), לולאות, עצירה, ועוד.
6. חיישנים - בדיקה של מקרים\אירועים - קלט.

הנה דוגמה לקוד פשוט שמבקש ממך את שמך ואז אומר לך שלום:

בהצלחה!

שליטה על מנוע סרוו על פי לחץ ברומטרי

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

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

התלמידים תכננו שהארדואינו "יחפש" את הערך של 3000 מ', אח"כ יחפש את הערך של 7000 מ' ולבסוף שוב את הערך של 3000 מ' ורק אז יפתח את המצנח. כמובן שאין מניעה במחינת התכנון הזה שהארדואינו ימדוד אפילו ערכים של 30,000 מ' אלא שיש מעין "טריגרים" שרק בסדר מסוים יפעילו את מנוע הסרוו שיפתח את המצנח.

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

בסיום העבודה, הגענו לקוד הזה:

#include <Wire.h> #include <Adafruit_Sensor.h> #include <Adafruit_BMP085_U.h> #include <LiquidCrystal.h> #include <Servo.h> Servo ServoMotor; Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085); LiquidCrystal lcd(12, 11, 5, 4, 3, 2); int distance; int maxDistance=0; int upMinimumDistance=900; int servoDistance=900; int planedPicDistance=850; int upMinimumDistanceFlag=0; int servoDistanceFlag=0; int planedPicDistanceFlag=0; void setup() { ServoMotor.attach(9); ServoMotor.write(180); pinMode(13, OUTPUT); digitalWrite(13, LOW); Serial.begin(9600); Serial.println("Pressure Sensor Test"); Serial.println(""); lcd.begin(16, 2); if(!bmp.begin()) { Serial.print("Ooops, no BMP085 detected ... Check your wiring or I2C ADDR!"); while(1); } } void loop() { sensors_event_t event; bmp.getEvent(&event); if (event.pressure) { Serial.print("Pressure: "); Serial.print(event.pressure); Serial.println(" hPa"); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Pressure: "); lcd.setCursor(3, 1); lcd.print(event.pressure); } else { Serial.println("Sensor error"); } if (event.pressure > maxDistance) maxDistance= event.pressure; if (upMinimumDistanceFlag == 0 && event.pressure < upMinimumDistance ){ upMinimumDistanceFlag = 1; Serial.println("passed minimum - going up"); } if (planedPicDistanceFlag == 0 && event.pressure < planedPicDistance){ planedPicDistanceFlag = 1; Serial.println("passed planed pic - going up"); } if (planedPicDistanceFlag == 1 && event.pressure > maxDistance){ planedPicDistanceFlag = 2; Serial.println("passed max pic - going down"); } if (planedPicDistanceFlag > 0 && event.pressure > servoDistance){ servoDistanceFlag = 1; Serial.println("can open servo - going down"); } if (servoDistanceFlag == 1){ servoDistanceFlag=2; digitalWrite(13, HIGH); Serial.println("sero opened"); ServoMotor.write(0); } delay(1000); }

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

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

אז מה אתם אומרים? עובד או לא?

מצרף לכם סרטון וידאו לצפיה:

גישה באמצעות כרטיס RFID

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

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

מוכנים?

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

רכיבים (חלקם ישמשו אותנו רק בשלב ב' אולם כדאי כבר לבנות את הכל עכשיו): 

• לוח ארדואינו
• מטריצה
• קורא/ כותב RFID מסוג RC522
• נורת לד אדומה
• נורת לד ירוקה
• 2 נגדים בערך של 220Ω
• חוטים... 

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

תחילה נבנה את המעגל: 

הנורות לא ישמשו אותנו בשלב הראשון. נגיע אליהם בשלב ב'...

זה אמור להראות בערך כך (הנורות לא אמורות לדלוק עדיין..):

לאחר שהרכבנו הכל - 

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

עכשיו אנחנו מוכנים להעלות את הקוד: 

#include <SPI.h> #include <MFRC522.h> #define RST_PIN 9 // Configurable, see typical pin layout above #define SS_PIN 10 // Configurable, see typical pin layout above MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance void setup() { Serial.begin(9600); // Initialize serial communications with the PC SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card Serial.println(F("Write personal data on a MIFARE PICC ")); } void loop() { // Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory. MFRC522::MIFARE_Key key; for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF; // Look for new cards if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Select one of the cards if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.print(F("Card UID:")); //Dump UID for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); } Serial.print(F(" PICC type: ")); // Dump PICC type MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); Serial.println(mfrc522.PICC_GetTypeName(piccType)); byte buffer[34]; byte block; MFRC522::StatusCode status; byte len; Serial.setTimeout(20000L) ; // wait until 20 seconds for input from serial // Ask personal data: Family name Serial.println(F("Type Family name, ending with #")); len = Serial.readBytesUntil('#', (char *) buffer, 30) ; // read family name from serial for (byte i = len; i < 30; i++) buffer[i] = ' '; // pad with spaces block = 1; //Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } else Serial.println(F("PCD_Authenticate() success: ")); // Write block status = mfrc522.MIFARE_Write(block, buffer, 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } else Serial.println(F("MIFARE_Write() success: ")); block = 2; //Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Write block status = mfrc522.MIFARE_Write(block, &buffer[16], 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } else Serial.println(F("MIFARE_Write() success: ")); // Ask personal data: First name Serial.println(F("Type First name, ending with #")); len = Serial.readBytesUntil('#', (char *) buffer, 20) ; // read first name from serial for (byte i = len; i < 20; i++) buffer[i] = ' '; // pad with spaces block = 4; //Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Write block status = mfrc522.MIFARE_Write(block, buffer, 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } else Serial.println(F("MIFARE_Write() success: ")); block = 5; //Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Write block status = mfrc522.MIFARE_Write(block, &buffer[16], 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } else Serial.println(F("MIFARE_Write() success: ")); Serial.println(" "); mfrc522.PICC_HaltA(); // Halt PICC mfrc522.PCD_StopCrypto1(); // Stop encryption on PCD }

אחרי שהעלינו את הקוד נפתח מסך סיריאלי:

1. נעביר את הכרטיס על כותב הכרטיסים (RFID)
2. נקיש # ו"שלח" או ENTER
3. נקיש NADAV ואחר כך # 
4. נלחץ על "שלח" או ENTER. 
5. נשים את הכרטיס בצד.
6. נחזור על התהליך עם הכרטיס השני אבל הפעם נחליף את NADAV ב TAMAR. 

כעת יש לנו שני כרטיסים שצרובים עליהם שני שמות שונים: TAMAR ו NADAV.

שלב ב' - קוד הרשאה 

כעת, צריך להעלות את הקוד החדש שיאפשר גישה ל TAMAR ויחסום את NADAV: 

#include <SPI.h> #include <MFRC522.h> #define RST_PIN 9 #define SS_PIN 10 MFRC522 mfrc522(SS_PIN, RST_PIN); void setup() { Serial.begin(9600); SPI.begin(); mfrc522.PCD_Init(); Serial.println(F("Read personal data on a MIFARE PICC:")); pinMode(7,OUTPUT); pinMode(6,OUTPUT); } void loop() { digitalWrite(7,HIGH); MFRC522::MIFARE_Key key; for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF; byte block; byte len; MFRC522::StatusCode status; if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(F("**Card Detected:**")); mfrc522.PICC_DumpDetailsToSerial(&(mfrc522.uid)); Serial.print(F("Name: ")); byte buffer1[18]; block = 4; len = 18; status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 4, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("Authentication failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } status = mfrc522.MIFARE_Read(block, buffer1, &len); if (status != MFRC522::STATUS_OK) { Serial.print(F("Reading failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } for (uint8_t i = 0; i < 16; i++) { if (buffer1[i] != 32) { Serial.write(buffer1[i]); } if (buffer1[i] == (84,65,77,65,82)) { Serial.println(""); Serial.println("******************************************************"); Serial.println("OK"); Serial.println("******************************************************"); digitalWrite(7,LOW); digitalWrite(6,HIGH); delay(5000); digitalWrite(6,LOW); digitalWrite(7,HIGH); } } Serial.print(" "); byte buffer2[18]; block = 1; status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 1, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("Authentication failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } status = mfrc522.MIFARE_Read(block, buffer2, &len); if (status != MFRC522::STATUS_OK) { Serial.print(F("Reading failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } for (uint8_t i = 0; i < 16; i++) { Serial.write(buffer2[i] ); } Serial.println(F("\n**End Reading**\n")); delay(1000); mfrc522.PICC_HaltA(); mfrc522.PCD_StopCrypto1(); }

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

1. העבירו את הכרטיס של NADAV ובדקו מה קורה
2. העבירו את הכרטיס של TAMAR ובדקו מה קורה. 

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

if (buffer1[i] == (84,65,77,65,82))

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

בהצלחה!

טבלת ASCII (התייחסו לטור ה Dec וטור ה Char. התעלמו כרגע מטור ה Hex):

שלב ג' - הוספת כפתור לפתיחה

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

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

נתחיל?

תחילה נוסיף את הכפתור:

רכיבים נוספים:

• לחצן
• נגד 10KΩ
• כמה חוטים. 

נבנה את המעגל על פי התרשים הבא: 

למי שהתבלבל:

1. הוספנו לחצן שמקבל מתח מה 5V (ולשם כך פיצלנו את המתח כך שיגיע גם לקורא הכרטיסים וגם ללחצן). 
2. חיברנו את הצד השני של הלחצן ליציאה מספר 8. 
3. את אותו הצד חיברנו גם לשורת ה GND דרך נגד של 10KΩ. 

כעת נעלה את הקוד החדש שכולל את הפקודות ללחצן: 

#include <SPI.h> #include <MFRC522.h> #define RST_PIN 9 #define SS_PIN 10 MFRC522 mfrc522(SS_PIN, RST_PIN); int button = 8; void setup() { Serial.begin(9600); SPI.begin(); mfrc522.PCD_Init(); Serial.println(F("Read personal data on a MIFARE PICC:")); pinMode(7,OUTPUT); pinMode(6,OUTPUT); pinMode(button, INPUT); } void loop() { digitalWrite(7,HIGH); if(digitalRead(button) == HIGH){ Serial.println(""); Serial.println("******************************************************"); Serial.println("OK"); Serial.println("******************************************************"); digitalWrite(7,LOW); digitalWrite(6,HIGH); delay(5000); digitalWrite(6,LOW); digitalWrite(7,HIGH); } MFRC522::MIFARE_Key key; for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF; byte block; byte len; MFRC522::StatusCode status; if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } if ( ! mfrc522.PICC_ReadCardSerial()) { return; } Serial.println(F("**Card Detected:**")); mfrc522.PICC_DumpDetailsToSerial(&(mfrc522.uid)); Serial.print(F("Name: ")); byte buffer1[18]; block = 4; len = 18; status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 4, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("Authentication failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } status = mfrc522.MIFARE_Read(block, buffer1, &len); if (status != MFRC522::STATUS_OK) { Serial.print(F("Reading failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } for (uint8_t i = 0; i < 16; i++) { if (buffer1[i] != 32) { Serial.write(buffer1[i]); } if (buffer1[i] == (84,65,77,65,82)) { Serial.println(""); Serial.println("******************************************************"); Serial.println("OK"); Serial.println("******************************************************"); digitalWrite(7,LOW); digitalWrite(6,HIGH); delay(5000); digitalWrite(6,LOW); digitalWrite(7,HIGH); } } Serial.print(" "); byte buffer2[18]; block = 1; status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, 1, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("Authentication failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } status = mfrc522.MIFARE_Read(block, buffer2, &len); if (status != MFRC522::STATUS_OK) { Serial.print(F("Reading failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } for (uint8_t i = 0; i < 16; i++) { Serial.write(buffer2[i] ); } Serial.println(F("\n**End Reading**\n")); delay(1000); mfrc522.PICC_HaltA(); mfrc522.PCD_StopCrypto1(); }

בהצלחה!!

טנק בשלט רחוק

איך יוצרים טנק עם שלט רחוק?

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

נתחיל?

רכיבים:

• שני לוחות ארדואינו
• רסיבר RF - מקלט 
• טרנסמיטר RF - משדר
• טנק (או כל כלי רכב אחר בעל שני מנועי DC) 
• דרייבר shield למנועי DC
• ג'ויסטיק 
• מספר חוטים
• מטריצה קטנה 
• סוללות לטנק (9V) כולל חיבור מיוחד לארדואינו (+ סוללה אחת 9V בשביל הדרייבר ללא חיבור מיוחד לארדואינו)

נתחיל מהטנק עצמו: 

את המנועים נחבר לדרייבר כמו שכבר הסברנו ו"נלביש" את הדרייבר על הארדואינו. נחבר סוללה אחת לדרייבר ואחת נוספת לארדואינו. 

בנוסף, נחבר לדרייבר ליציאה מספר 2 את RF recivier וכמו כן - נספק לו 5V ו GND. 

לאחר שסיימנו, נעלה את הקוד:

#include <RCSwitch.h> RCSwitch mySwitch = RCSwitch(); int pos = 0; void setup() { Serial.begin(9600); pinMode(12, OUTPUT); pinMode(9, OUTPUT); pinMode(13, OUTPUT); pinMode(8, OUTPUT); mySwitch.enableReceive(0); } void loop() { if (mySwitch.available()) { int value = mySwitch.getReceivedValue(); if (value > 0) { if (mySwitch.getReceivedValue()==1){ digitalWrite(12, HIGH); digitalWrite(9, LOW); analogWrite(3, 255); digitalWrite(13, HIGH); digitalWrite(8, LOW); analogWrite(11, 255); delay(1000); digitalWrite(9, HIGH); digitalWrite(8, HIGH); } else if (mySwitch.getReceivedValue()==2){ digitalWrite(12, LOW); digitalWrite(9, LOW); analogWrite(3, 255); digitalWrite(13, LOW); digitalWrite(8, LOW); analogWrite(11, 255); delay(1000); digitalWrite(9, HIGH); digitalWrite(8, HIGH);} else if (mySwitch.getReceivedValue()==3){ digitalWrite(12, HIGH); digitalWrite(9, LOW); analogWrite(3, 255); digitalWrite(13, LOW); digitalWrite(8, LOW); analogWrite(11, 255); delay(1000); digitalWrite(9, HIGH); digitalWrite(8, HIGH);} else if (mySwitch.getReceivedValue()==4){ digitalWrite(12, LOW); digitalWrite(9, LOW); analogWrite(3, 255); digitalWrite(13, HIGH); digitalWrite(8, LOW); analogWrite(11, 255); delay(1000); digitalWrite(9, HIGH); digitalWrite(8, HIGH);} else if (mySwitch.getReceivedValue()==5){ digitalWrite(9, HIGH); digitalWrite(8, HIGH); } } mySwitch.resetAvailable(); } }

שימו לב!

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

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

שימו לב: 

את ה RF transmitter, המשדר, אנו נחבר ליציאה מס' 10 בארדואינו ונספק לו בנוסף 5V ו GND. 

את הג'ויסטיק נחבר על פי העיקרון הבא: 

1. את ה VCC נחבר ל 5V
2. את ה GND נחבר ל GND
3. את ה SEL נשאיר ללא חיבור
4. את שני החיבורים של הנתונים (שמסומנים אחרת בכל ג'ויסטיק...) - נחבר ל A0 ו A1. אם נראה שהצירים שלנו הפוכים בסופו של דבר - נחליף בין החוטים. 

לאחר שסיימנו - נעלה את הקוד: 

#include <RCSwitch.h> RCSwitch mySwitch = RCSwitch(); int hozdead= 0 ; int verdead= 0 ; int pos = 0; int oldpos=100; int val = 0; int val2 = 0; void setup() { Serial.begin(9600); mySwitch.enableTransmit(10); } void loop() { //Read JoyStick val = analogRead(0)-510; val2 = analogRead(1)-536; Serial.println(val); Serial.println(val2); //UP 1 if (val> verdead+30){pos=1; Serial.println(pos);} //DOWN 2 if (val< verdead-30){pos=2; Serial.println(pos);} //RIGHT 3 if (val2> hozdead+30){pos=4; Serial.println(pos);} //LEFT 4 if (val2< hozdead-30){pos=3; Serial.println(pos);} //DEAD ZONE 5 if (val>verdead-20 && val< verdead+20 && val2>hozdead-20 && val2< hozdead+20) { pos=5; Serial.println(pos); } mySwitch.send(pos, 23); }

ועכשיו שימו לב: 

את השורות האלו -

val = analogRead(0)-510; val2 = analogRead(1)-536;

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

• להחליף את ה 510 ב 0
• להחליף את ה 536 ב 0

להעלות את הקוד ולפתוח מסך סיריאלי. כעת אתם אמורים לראות 4 מספרים: 

מספר שמבטא את הסטיה של הציר הראשון

מספר שמבטא את הסטיה של הציר השני

ועוד שני מספרים מ 1/2/3/4 או לחלופין - 5. 

אם אתם רואים 5 - הג'ויסטיק מאוזן ולא צריך שיפור. 

אם אתם רואים 1/2/3/4 - תרשמו את המספר שמבטא את הסטייה של הציר הראשון כחיסור מהתוצאה של קריאת הציר (איפה שאני רשמתי 510) ותרשמו את המספר השני בשורה השנייה (איפה שרשמתי 536).

זהו!

כעת - הכל מוכן לפעולה!

בהצלחה!!

ולסיום עוד תובנה אחת:

החוליה החלשה כאן בכל הסיפור זה הסוללות: סוללות 9V נטענות לא מספיק חזקות בשביל להניע את הטנק וסוללות לא נטענות "נזללות". אני מקווה לקבל מ Ebay סוף סוף את הסוללות הנטענות AA שהזמנתי יחד עם החיבורים שלהם לארדואינו. נראה לי שיהיה אפשר ליצור כך משהו חזק בהרבה שיתפקד לאורך זמן.