ארדואינו לאונרדו / 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 שהזמנתי יחד עם החיבורים שלהם לארדואינו. נראה לי שיהיה אפשר ליצור כך משהו חזק בהרבה שיתפקד לאורך זמן. 

דרייבר מגן (shield) עם שני מנועי DC

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

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

מתחילים? 

רכיבים: 

• לוח ארדואינו UNO
• שני מנועי DC פשוטים 
• 2 X סוללה 9V 
• מתאם לסוללה 9V לארדואינו
• מתאם לסוללה 9V ללא חיבור לארדואינו (שני חוטים..)
• דרייבר מתאים (ראה תמונה)

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

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

לחיבור השמאלי ביותר שמסומן ב B- >> נחבר את המינוס של אחד המנועים

לחיבור השני משמאל שמסומן ב B+ >> נחבר את הפלוס של אותו המנוע. 

לחיבור השלישי משמאל שמסומן ב A- >> נחבר את המינוס של המנוע השני

ולחיבור הרביעי משמאל שמסומן ב A+ >> נחבר את הפלוס של המנוע השני. 

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

לחיבור הימני ביותר שמסומן ב GND >> נחבר את המינוס של הסוללה

ולחיבור השני שמסומן ב VIN >> נחבר את הפלוס של הסוללה. 

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

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

הקוד:

void setup() { pinMode(12, OUTPUT); pinMode(9, OUTPUT); pinMode(13, OUTPUT); pinMode(8, OUTPUT); } void loop(){ digitalWrite(12, HIGH); digitalWrite(9, LOW); analogWrite(3, 255); digitalWrite(13, HIGH); digitalWrite(8, LOW); analogWrite(11, 255); delay(3000); digitalWrite(9, HIGH); digitalWrite(8, HIGH); delay(1000); 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); delay(1000); }

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

pinMode(12, OUTPUT); pinMode(9, OUTPUT);

יציאה דיגיטלית מספר 12 - שולטת על מנוע A ואילו היציאה דיגיטלית מספר 9 עוצרת את מנוע A.

pinMode(13, OUTPUT); pinMode(8, OUTPUT);

בשורות הבאות ניתן לראות שיציאה מספר 13 - שולטת על מנוע B ויציאה מספר 8 - עוצרת את מנוע B.

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

1. להפעיל את היציאה הדיגיטלית של אותו המנוע - 12 או 13: HIGH לנסיעה קדימה ו LOW לנסיעה אחורה. 
2. לבלום את הבלם של אותו המנוע - 8 או 9: להגדיר לו LOW. 
3. להגדיר את המהירות של המנוע: מנוע A יוגדר על ידי יציאה 3 בערכים של 0-255 ומנוע B יוגדר ביציאה 11 על ידי ערכים של 0-255. 

הפעלה קדימה של מנוע A במלוא המהירות תראה כך: 

digitalWrite(12, HIGH); digitalWrite(9, LOW); analogWrite(3, 255);

ואם נרצה להפעיל את מנוע B לאחור בחצי מהירות (כמעט חצי...) זה יראה כך:

digitalWrite(13, LOW); digitalWrite(8, LOW); analogWrite(11, 127);

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

(ואם זה  לא התוצאה שקיבלתם - תחזרו בבקשה להערה למעלה)

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

בהצלחה!!

ברומטר

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

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

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

רכיבים:

• לוח ארדואינו
• מטריצה
• ברומטר
• מספר חוטים
• מסך LCD (לשלב ב')
• פוטנציומטר (לשלב ב'). 
• סוללה - אופציה (לשלב ב')

שלב א' - ברומטר ומסך סיריאלי

תחילה - מרכיבים את המעגל על פי התרשים. שימו לב שהברומטר יכול לקבל 3.3V ועלול להישרף ממתח של 5V!!!

ואחרי שהרכבתם - מורידים את הספריות הבאות:

• Adafruit_Sensor
• Adafruit_BMP085_Unified

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

אצלי היא נמצאת כאן: 

C:\Program Files (x86)\Arduino\libraries

וכאשר הספריות במקומן - נכנסים לארדואינו ומדביקים את הקוד:

#include <Wire.h> #include <Adafruit_Sensor.h> #include <Adafruit_BMP085_U.h> Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085); void setup(void) { Serial.begin(9600); Serial.println("Pressure Sensor Test"); Serial.println(""); if(!bmp.begin()){ Serial.print("Ooops, no BMP085 detected ... Check your wiring or I2C ADDR!"); while(1); } } void loop(void) { sensors_event_t event; bmp.getEvent(&event); if (event.pressure){ Serial.print("Pressure: "); Serial.print(event.pressure); Serial.println(" hPa"); } else{ Serial.println("Sensor error"); } delay(250); }

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

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

שלב ב' - ברומטר עצמאי

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

נתחיל?

תחילה מוסיפים למעגל מסך LCD עם 12 חיבורים וכמו כן - מוסיפים סוללה.

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

#include <Wire.h> #include <Adafruit_Sensor.h> #include <Adafruit_BMP085_U.h> #include <LiquidCrystal.h> Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085); LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup(void) { 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(void) { 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"); } delay(250); }

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

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

והנה הפעמון בפעולה:

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

מחיאת כף

תמיד חלמתם להדליק את האור במחיאת כף? עם ארדואינו זה ממש קל!

רכיבים:

• לוח ארדואינו
• מטריצה 
• מיקרופון לארדואינו 
• נורת לד
• נגד 220Ω

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

בניית המעגל פשוטה:

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

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

1. VCC >> יתחבר ל 5V בארדואינו. 
2. GND >> יתחבר ל GND בארדואינו. 
3. OUT >> יתחבר ליציאה דיגיטלית 3 בארדואינו (D3). 

אם במקום OUT יש לכם 2 יציאות בשם A0 ו- D0 - השאירו את יציאת ה A0 ללא חיבור ואת ה D0 חברו ליציאה דיגיטלית 3 בארדואינו.

זה אמור להראות בערך כך:

אחרי שחיברתם את המעגל, הגיע הזמן להעלות את הקוד: 

int Led = 13 ; int buttonpin = 3; int val = 0; void setup () { pinMode (Led, OUTPUT) ; pinMode (buttonpin, INPUT) ; } void loop () { val = digitalRead(buttonpin); if (val == HIGH) { digitalWrite (Led, HIGH); } else { digitalWrite (Led, LOW); } }

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

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

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

תהנו!



וממש ממש לסיום:

1. כמובן שבמקום נורת לד ניתן לחבר לרשת החשמל הביתית בעזרת Relay.
2. ניתן לשנות את ה Delay  בקוד כך שמחיאת כף תדליק את הנורה לזמן רב יותר. לחלופין - ניתן לשנות את הקוד לחלוטין כך שמחיאת כף אחת תדליק את הנורה ואילו מחיאת כף נוספת תכבה אותה. ניתן לראות דוגמא לקוד דומה כאן (במעגל השלישי).

בהצלחה!

בית חכם

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

החיסרון - עשה זאת בעצמך (DIY)... 

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

שלב א' - מנגנון אזעקה לדלת

רכיבים: 

• לוח ארדואינו
• נורת לד
• נגד 220𝛀
• נגד 10K𝛀
• מספר חוטים
• מנגנון לדלת (ראה הערה)

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

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

נרכיב לפי התרשים: 

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

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

int door_open = 10; void setup() { pinMode(door_open, INPUT); pinMode(11,OUTPUT); } void loop() { if(digitalRead(door_open) == LOW){ digitalWrite(11,HIGH); } else{ digitalWrite(11,LOW); } }


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

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

שלב ב' - שילוב זמזם

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

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

• נגד 100𝛀 (גם נגד של 330𝛀 יעבוד אבל יחליש את עוצמת האזעקה)
• זמזם
• חוטים נוספים 

נוסיף למעגל שלנו את הזמזם על פי התרשים הבא: 

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

int door_open = 10; int speakerPin = 12; void setup() { pinMode(door_open, INPUT); pinMode(11,OUTPUT); } void loop() { if(digitalRead(door_open) == LOW){ digitalWrite(11,HIGH); tone(speakerPin, 300); delay(200); noTone(speakerPin); delay(200); } else{ digitalWrite(11,LOW); } }



כעת ניתן לשמוע את האזעקה ולא להסתפק רק בהבהוב של הנורה:

שלב ג' - תצוגת מסך

לפני תחילת השלב הזה, נפנה את יציאות 11,12 לטובת המסך:

1. נעביר את החוט מיציאה 11 אל יציאה מספר 6
2. נעביר את החוט מיציאה מספר 12 אל יציאה מספר 7

כעת, נוסיף את המסך.

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

• מסך עם 12 חיבורים 
• פוטנציומטר
• חוטים... 

נוסיף את המסך למעגל על פי התרשים הבא: 

ליתר ביטחון - מצרף לכם את ההוראות גם בכתב (התרשים אכן עמוס ומבלבל אבל סומך עליכם שתצליחו...):

(יציאות ה LCD נמנות כאן משמאל לימין!)

• יציאה מספר 1 במסך ה LCD >>> ל GND בארדואינו
• יציאה מספר 2 במסך ה LCD >>> ל 5V בארדואינו
• יציאה מספר 3 במסך ה LCD >>> לחיבור האמצעי של הפוטנציומטר
• יציאה מספר 4 במסך ה LCD >>> ליציאה 12 בארדואינו
• יציאה מספר 5 במסך ה LCD >>> ל GND בארדואינו
• יציאה מספר 6 במסך ה LCD >>> ליציאה 11בארדואינו
• יציאה מספר 7 במסך ה LCD >>> ללא חיבור
• יציאה מספר 8 במסך ה LCD >>> ללא חיבור
• יציאה מספר 9 במסך ה LCD >>> ללא חיבור
• יציאה מספר 10 במסך ה LCD >>> ללא חיבור
• יציאה מספר 11 במסך ה LCD >>> ליציאה 5 בארדואינו
• יציאה מספר 12 במסך ה LCD >>> ליציאה 4 בארדואינו
• יציאה מספר 13 במסך ה LCD >>> ליציאה 3 בארדואינו
• יציאה מספר 14 במסך ה LCD >>> ליציאה 2 בארדואינו
• יציאה מספר 15 במסך ה LCD >>> ל 5V בארדואינו
• יציאה מספר 16 במסך ה LCD >>> ל GND בארדואינו

במציאות זה כמובן נראה גרוע הרבה יותר...

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

1. היציאות שהוחלפו בתחילת שלב זה באו לידי ביטוי בקוד. 
2. נוספו הפקודות של המסך. 

#include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); int door_open = 10; int speakerPin = 7; void setup() { pinMode(door_open, INPUT); pinMode(6,OUTPUT); lcd.begin(16, 2); } void loop() { if(digitalRead(door_open) == LOW){ digitalWrite(6,HIGH); lcd.setCursor(0, 0); lcd.print("-----ALARM!-----"); lcd.setCursor(3, 1); lcd.print("Door open!"); tone(speakerPin, 300); delay(200); lcd.clear(); noTone(speakerPin); delay(200); } else{ digitalWrite(6,LOW); } }

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

שלב ד' - תצוגת טמפרטורה

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

רכיבים נוספים לשלב זה:

• חיישן טמפרטורה אנלוגי מסוג TMP 36GZ

שימו לב!!

העמידו את חיישן הטמפרטורה כאשר הכיתוב נמצא מולכם ואילו הצד הקמור של החיישן פונה כלפי חוץ. כאשר החיישן במצב זה, הרגל השמאלית שלו - צריכה לקבל את ה 5V ואילו הרגל הימנית - מתחברת ל GND. אם תהפכו את היוצרות, תקבלו חיישן חם מאד שעלול לגרום לכוויות ואף להישרף!!

מקווה שכתבתי את זה מספיק בולט...

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

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

#include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); int door_open = 10; int speakerPin = 7; void setup() { pinMode(door_open, INPUT); pinMode(6,OUTPUT); lcd.begin(16, 2); } void loop() { if(digitalRead(door_open) == LOW){ digitalWrite(6,HIGH); lcd.setCursor(0, 0); lcd.print("-----ALARM!-----"); lcd.setCursor(3, 1); lcd.print("Door open!"); tone(speakerPin, 300); delay(200); lcd.clear(); noTone(speakerPin); delay(200); } else{ digitalWrite(6,LOW); int t = analogRead(A0) / 2.046; t=t-32; t=t*5/9; lcd.setCursor(2, 0); lcd.print("Temperature:"); lcd.setCursor(6, 1); lcd.print(t); lcd.setCursor(8, 1); lcd.print("'C"); delay(200); } }

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

שלב ה' - בקרת אקלים 

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

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

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

• מאוורר

זה התרשים של המערכת עם בקרת האקלים:

והקוד שודרג כך שהמאוורר יופעל כאשר הטמפרטורה עולה מעל 22 מעלות צלזיוס.


#include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); int door_open = 10; int speakerPin = 7; void setup() { pinMode(door_open, INPUT); pinMode(6,OUTPUT); pinMode(13,OUTPUT); lcd.begin(16, 2); } void loop() { if(digitalRead(door_open) == LOW){ digitalWrite(6,HIGH); lcd.setCursor(0, 0); lcd.print("-----ALARM!-----"); lcd.setCursor(3, 1); lcd.print("Door open!"); tone(speakerPin, 300); delay(200); lcd.clear(); noTone(speakerPin); delay(200); } else{ digitalWrite(6,LOW); int t = analogRead(A0) / 2.046; t=t-32; t=t*5/9; lcd.setCursor(2, 0); lcd.print("Temperature:"); lcd.setCursor(6, 1); lcd.print(t); lcd.setCursor(8, 1); lcd.print("'C"); delay(200); if(t>=23){ digitalWrite(13,HIGH); } else{ digitalWrite(13,LOW); } } }

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






שלב ו' - לאן ממשיכים מכאן? 

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

בהצלחה!!