מדריך ארדואינו למתחילים חלק א'

מדריך ארדואינו למתחילים חלק א'

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

 

מבוסס על ערכת ארדואינו למתחילים

 

ארדואינו אונו R3
ארדואינו אונו R3

פרקים:

  1. מה זה ארדואינו ומה אפשר לעשות איתו?
  2. כיבוי והדלקת נורה
  3. הפעלת זמזם
  4. אלקטרוניקה בסיסית
  5. נורת לד RGB
  6. קבלת קלט מכפתורים ופוטנציומטר
  7. תקשורת טורית דרך ה-USB
  8. אוגר הזזה
  9. קריאה של חיישנים
  10. שימוש בספריות
  11. מטריצת לדים
  12. ג'ויסטיק אנלוגי
  13. חיישן תנועה אינפרא אדום
  14. ממסר
  15. חיישן מרחק אולטראסוני
  16. תצוגת ספרות 7 מקטעים
  17. מקורות כח

מה זה ארדואינו ומה אפשר לעשות איתו?

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

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

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

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

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

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

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

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

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

לוחות שונים של ארדואינו

book-arduino_boards

הארדואינו אונו (UNO) הוא הלוח הנפוץ והפופולרי ביותר ומשמש לרוב הפרויקטים ההתחלתיים.

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

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

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

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

book-arduino-reference

Atmel atmega328

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

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

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

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

האונו מופעל ע"י כבל USB אשר מספק לו מתח של 5 וולט וגם מאפשר העברת נתונים – כתיבת התוכנה מסביבת הפיתוח שעל המחשב לארדואינו.

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

ווינדוס – היכנסו לאתר הראשי של ארדואינו https://www.arduino.cc , היכנסו להורדות ובחרו windows installer. לחצו על just download. לאחר ההורדה לחצו לחיצה כפולה על האייקון ואשרו את ההתקנה. כעת התוכנה תותקן על המחשב שלכם.

 

book-arduino_ide

book-arduino_ide-2

 

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

אם לא בחרתם ב windows insaller אלא הורדתם את קובץ ה zip יכול להיות שיהיה  צורך להוריד דרייברים. אם המחשב לא מזהה את את חומרת הארדואינו צריך ללחוץ לחיצה ימנית על המחשב שלי, מאפיינים, ומנהל ההתקנים.

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

book-arduino_device_manager

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

sudo apt-get install arduino

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

sudo usermod -a -G dialout yourusername

כמובן החליפו את username בשם המשתמש שלכם.

עכשיו ניתן לחבר את הארדואינו למחשב ע"י כבל ה usb.

סיור בשקעי הארדואינו

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

הם למעשה בסיס הלוגיקה של הארדואינו והמתח שבו הם עובדים הוא 5 וולט. ל 7 פינים מתוך ה 13 ישנה יכולת לספק מתח מ 0 עד 5 וולט בדרך שנקראת pwm והם מסומנים ע"י תלתל.

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

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

ישנם פינים של אספקת 5 וולט ו 3.3 וולט והם מספקים אספקה קבועה של מתח להתקנים נוספים כמו חיישנים, כלומר לא ניתן לשלוט עליהם ע"י התוכנה.

הפין שנקרא VIN הוא פין שנותן לנו לספק מתח לארדואינו ממקור כח חיצוני לדוגמה בטריה והמתח שהוא אמור לקבל הוא מ 5 וולט ועד 20 וולט ולאחר מכן המתח מורד ל5 וולט ומומלץ לספק דרכו 9 וולט .

פינים 0 ו 1 יכולים לשמש גם להעברת מידע לבקרים אחרים וכך גם SDA ו SCL שמיועדים לתקשורת בפרוטוקול I2C.
דבר אחד שחשוב לזכור הוא שהיכולת של הפינים הדיגיטליים היא מוגבלת בערך ל 40 מיליאמפר לכל פין.

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

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

כך נראית סביבת הפיתוח של ארדואינו:

 

book-arduino_sketches

 

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

ישנן שתי פונקציות שחייבות להופיע בכל סקיצה שאנחנו כותבים:

void setup היא פונקציה שרצה פעם אחת כשהארדואינו מופעל. Void loop היא פונקציה שרצה בצורה אינסופית מרגע שהארדואינו נדלק ועד שאנחנו מכבים אותו.

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

 


כיבוי והדלקת נורה

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

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

מטריצת חיבורים

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

ארדואינו ומטריצה

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

book-arduino_breadboard-2

הבהוב נורת לד

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

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

 

ארדואינו הפעלת נורה

 

חברו את כבל ה USB בין המחשב לארדואינו – הארדואינו עכשיו פועל.

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

עכשיו ניתן לכתוב את התוכנה:

void setup() { // function that runs once
  pinMode(13, OUTPUT); // set pin 13 (led) to output
}
void loop() { // function that runs infinitely
  digitalWrite(13, HIGH); // turn pin 13 on
  delay(2000); // wait 2 seconds
  digitalWrite(13, LOW); // turn pin 13 off
  delay(2000); // wait 2 seconds
}

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

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

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

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

כתיבת קוד בארדואינו

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

כל סקיצה של ארדואינו חייבת לכלול לפחות שתי פונקציות – setup ו loop למרות שהן יכולות להישאר ריקות.

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

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

הפקודה השנייה היא delay שאומרת לקוד להמתין והערך שהיא מקבלת נמדד במילישניות – 2000 מילישניות = 2 שניות. בתוך הפונקציות בסוף כל שורה יש גרשיים סופיות שהן כמו נקודה בסוף משפט.

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

 void setup() {

    pinMode(13, OUTPUT);

}

void loop() {

    digitalWrite(13, HIGH);

    digitalWrite(13, LOW);

}

עכשיו הנורה נשארת דולקת כל הזמן כי הקוד רץ מהר מדי כדי שנבחין בשינוי.

בואו ננסה לשחק קצת עם המספרים בפונקציית ה delay:

void setup() {

    pinMode(13, HIGH);

}

void loop() {

  digitalWrite(13, HIGH);

  delay(200);

  digitalWrite(13, LOW);

  delay(1300);
}

ועכשיו נשגע את הארדואינו:

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(50);
  digitalWrite(13, LOW);
  delay(50);
}

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

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

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

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

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

פונקציות בסיסיות

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

ישנן פונקציות בסיסיות שמגיעות עם סביבת הפיתוח וניתן גם לבנות פונקציות משלנו. הפונקציות הבסיסיות שמגיעות עם הארדואינו:
digitalWrite – מקבלת שתי ערכים שהם מספר פין ו HIGH או LOW. היא אומרת לארדואינו האם לספק מתח של 5 וולט לפין מסויים. בדרך כלל היא נמצאת בתוך פונקציית ה loop. דוגמה – digitalWrite(8, HIGH).

digitalRead – פונקצייה שקוראת את הערך המתקבל מפין מסויים בארדואינו. הערך יכול להיות 0 או 5 וולט זאת אומרת HIGH או LOW. מקבלת ערך אחד שהוא מספר פין. דוגמה – digitalRead(6).

analogRead – קוראת את הערך האנלוגי שמתקבל מפין מסויים. הערך המתקבל הוא בין 0- 1023 ומייצג את כמות המתח המתקבלת. לארדואינו יש 6 פינים לכניסה אנלוגית שממוספרים A0-A5. דוגמה – analogRead(A0).

analogWrite – פונקצייה שמוציאה כמות מתח משתנה ומבוטאת בערכים בין 0-255 . הפינים שבהם ניתן לעשות זאת הן פינים דיגיטליים שיש לידם תלתל(3,5,6,9,10,11) והפעולה הזו נקראית PWM שהיא פעולה שמוציאה כביכול מתח אנלוגי מפין דיגיטלי. דוגמה – analogWrite(3, 128).

pinMode – בניגוד לפונקציות הקודמות הפונקציה הזו נמצאת בתוך פונקציית ה setup. היא קובעת מראש האם אנחנו רוצים לכתוב או לקרוא את הערך מפין מסוים. היא מקבלת שני ערכים שהם מספר פין ו INPUT או OUTPUT . דוגמה – pinMode(7, OUTPUT) .

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

 

הפעלה אנלוגית

בדוגמה הקודמת הפעלנו את נורת הלד ע"י הפין הדיגיטלי מספר 13. כשנשלחה הפקודה digitalWrite הפין סיפק לנורה מתח של 5 וולט.

ישנה עוד דרך לספק מתח לפינים של הארדואינו ע"י מתח משתנה שנקרא pwm. בצורה זו ניתן לשלוט ברמת המתח המסופק לפין. הפונקציה שמבצעת את זה נקראת analogWrite והיא מקבלת ערך מ 0 ל 255.

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

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

בואו נכתוב את הקוד הבא:

void setup() {
  pinMode(11, OUTPUT);
}

void loop() {
  analogWrite(11, 10);
  delay(1000);
  analogWrite(11, 40);
  delay(1000);
  analogWrite(11, 70);
  delay(1000);
  analogWrite(11, 100);
  delay(1000);
  analogWrite(11, 150)
  delay(1000);
  analogWrite(11, 250);
  delay(1000);
}

שימו לב שכל שנייה עוצמת הנורה עולה לפי הערך שאנחנו נותנים לה. אתם יכולים לשנות את הערכים ולבדוק מה קורה. שימו לב שהערכים המתאימים הם מ 0 ל 255.

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

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

for(initial value, end value, increment)

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

הכניסו את הקוד הבא לסביבת הפיתוח:

void setup(){
  pinMode (11, OUTPUT);
}

void loop(){
  for (int i=0; i<256; i++){ 
    analogWrite(11, i); 
    delay(10);
  }

for (int i=255; i>=0; i--){
  analogWrite(11, i);
  delay(10);
 }
}

כל 10 מילישניות ערך האינדקס שבמקרה זה קראנו לו i עולה בערך אחד עד שהוא מגיע לערך הסופי שקבענו שהוא 255. ++I אומר לערך לעלות באחד מהערך הנוכחי.

אחרי שהלולאה הראשונה מסתיימת אנחנו מבצעים לולאה נוספת שמורידה את הערך כל 10 מילישניות עד שהוא מגיע ל 0 וכך חוזר חלילה(זכרו שכל זה נמצא בתוך הלולאה האינסופית loop).
ללולאות יש חשיבות עצומה בעולם התכנה וככל שנבנה פרויקטים יותר מסובכים נשתמש בהם יותר. אפשר לשחק עם המספרים בתוך הלולאה כרצוננו לדוגמה:
int value=20; value<256; value=value+5

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

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


 הפעלת זמזם

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

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

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

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

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

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

tone(11, 500, 2000) יפעיל זמזם המחובר לפין 11 בתדר של 500 הרץ למשך 2 שניות.

 

book-arduino_buzzer-13


 

אלקטרוניקה בסיסית

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

 

book-arduino_electronics

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

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

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

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

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

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

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

לדוגמה במעגל חשמלי שמקור הכח שלו הוא 5 וולט(כמו בארדואינו), אנחנו מכניסים למעגל נגד של 330 אוהם ונורת לד. כמה זרם יעבור בנורה? יש לנו שני מטענים שכל אחד מהם לוקח כמות מתח מסוימת שמתחלקת במתח הכולל של המעגל.

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

2.5 לחלק ל 330 = 0.007 אמפר או 7 מיליאמפר. כמות זרם זו מספיקה כדי להאיר את הנורה ונמצאת בטווח הבטוח שלה שהוא עד 30 מיליאמפר בערך. אם נרצה להאיר אותה באור חזק יותר נקטין את ההתנגדות ע"י החלפת הנגד ל 220 אוהם – 2.5 חלקי 220 = 11 מיליאמפר.

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

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

רב מודד

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

book-arduino_multimeter

 

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

נציב אותה על הערך הגדול מההתנגדות שאנחנו מודדים, לדוגמה הנגד בתמונה הוא של 2.2 קילו אוהם אז נציב את הידית על 20K אוהם.

נצמיד את הזרועות לקצוות של נגד מסוים וההתנגדות תופיע על הצג:

book-arduino_multimeter-2

 

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

חברו חוט מיציאת 5 הוולט של הארדואינו דרך נגד של 220 אוהם ומשם לרב מודד ולGND. את הרב מודד נציב על 200 מיליאמפר כי זו הדרגה שמעל הזרם שאנחנו מודדים.

קודם כל נחשב את הזרם האמור להופיע ברב המודד, נחשב לפי חוק אוהם: מתח = זרם כפול התנגדות.
5/220 = 0.022 אמפר . נכפיל ב 1000 כדי להמיר למיליאמפר – 22 מיליאמפר.

book-multimeter-current

 

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

קריאה של נגדים

ניתן לקרוא את הערך של נגד בשתי צורות – ע"י מדידת התנגדות ברב מודד או על פי פסי הצבע המצוירים עליו.

book-resistor-values

 

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

לדוגמה נגד של 330 אוהם אמור להיראות כך: שני פסים כתומים שמסמלים 33 ופס חום שמסמל הכפלה בעשר. 33 כפול 10 שווה 330.

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

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

book-series-parallel-circuit

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

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

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

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

עוד על חיבור בטור ובמקביל:

חיבור בטור ומקביל

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

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


 נורת לד RGB

לנורה זו יש ארבעה פינים:

book-arduino_rgb

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

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

עכשיו נחבר חוט שחור מאחד החורים שבאותו הטור של הפין הארוך ונחבר אותו לשקע ה GND בארדואינו.
נחבר נגד 220 אוהם מהפין הימני לטור המקביל, ומהטור שלו נחבר חוט אדום לפין הדיגיטלי 7.

 

book-arduino_rgb2

 

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

void setup() {

    pinMode(7, OUTPUT);

 }

void loop() {

    digitalWrite(7, HIGH);

}

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

 

book-arduino_rgb3

 

האור הפך לכחול…נעביר את הרגל השמאלית של הנגד שקע אחד ימינה – האור הפך לירוק.

book-arduino_rgb4

 

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

 

book-arduino_rgb5

 

שילוב של צבעים שונים

עכשיו אפשר לקבל איזה צבע שרוצים ע"י שילוב של הצבעים:
סגול –

void setup() { 

  pinMode(9, OUTPUT); 

  pinMode(11, OUTPUT); 

}

void loop() { 

   digitalWrite(9, HIGH);

   digitalWrite(11, HIGH); 

}

צהוב –

void setup(){

  pinMode(9, OUTPUT); 

  pinMode(10, OUTPUT); 

  pinMode(11, OUTPUT); 

}

void loop() {

  analogWrite(9,20);

  analogWrite(10, 255);

  analogWrite(11, 255);

 }

אפשר להעזר בטבלת ה RGB לבחור את הצבע האהוב עליכם –

טבלת צבעי RGB


קבלת קלט מכפתורים ופוטנציומטר

פוטנציומטר

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

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

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

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

הארדואינו ממיר את הערך האנלוגי לערך דיגיטלי ע"י ממיר של 10 ביט… 2 בחזקת 10 זה 1024 כך שמתוך אינסוף ערכים שהפין האנלוגי מקבל הוא צריך ליצור איזה שהן מדרגות שנעות מ 0 ל 1023 כשכל מדרגה היא בערך 0.005 וולט.

ככל שממיר יהיה בעל יותר ביט רמת הדיוק שלו תעלה. אם לדוגמה נעבוד עם ממיר אנלוגי-דיגיטלי של 11 ביט רמת הרזולוציה תהיה 0-2048.

הגיע הזמן לחבר את הפוטנציומטר בתמונה.
יש לו שלוש רגליים – השמאלית והימנית(לא משנה איזה) הולכות ל GND ו 5 וולט. האמצעית הולכת לאחד הפינים האנלוגיים(A0-A6) . במקרה זה נחבר את הרגל האמצעית ל A0. את נורת הלד נחבר לפין דיגיטלי מספר 9.

ארדואינו הפעלת פוטנציומטר

יש עוד בעיה אחת שאנחנו צריכים לפתור – הכניסה האנלוגיות מפיקה ערכים מ 0 עד 1024 בעוד היציאה האנלוגית מ 0 עד 255. ישנה פונקציה מובנית בארדואינו שפותרת בעיה זו ונקראת map.

היא מקבלת 5 ערכים שמופרדים בפסיקים – הראשון הוא הערך המתקבל, השני והשלישי הם הטווח המתקבל והרביעי והחמישי הן הטווח הרצוי. אנחנו רוצים להמיר מטווח של 0-1023 לטווח של 0-255. הנה הקוד:

 

 void setup() {

    pinMode(9, OUTPUT);// set led pin to output

    pinMode(A0, INPUT); // set analog pin A0 to input

 }

void loop() {  // take the value from A0 and map it from 0-1023 to 0-255

    analogWrite(9, map(analogRead(A0), 0, 1023, 0, 255));

 }

אנחנו למעשה שולחים לרגל 9 את הערך שמתקבל מהפוטנציומטר – שינוי בהתנגדות הפוטנציומטר הופך לשינוי בערך שאנחנו שולחים לרגל 9 ומשם לנורת הלד.

קלט מכפתור

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

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

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

אנחנו רוצים לקבוע ברירת מחדל לכפתור ע"י חיבור נגד ל GND. שיטה זו נקראת PULL DOWN כי אנחנו מושכים את הכפתור למטה ל GND. נגד פופולרי להשתמש כ- PULL DOWN RESISTOR הוא 10K.

ארדואינו הפעלת כפתור

בדוגמה זו נקבע את פין הקלט של הכפתור ל 10, ואת פין הפלט של הנורה ל 11.

שרטוט מעגלים

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

book-fritzing_button

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

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

book-fritzing_button2

נכניס את הקוד הבא:

int button = 10; // create variable with name button and number 10

 int led = 11; // create variable with name led and value 11

 void setup() {

     pinMode(button, INPUT); // set button pin to input

     pinMode(led, OUTPUT); // set led pin to output  }

void loop() {

      if(digitalRead(button) == HIGH){  // if we press the button

        digitalWrite(led, HIGH); // turn on led

  }

    else{ // if we don't press the button

        digitalWrite(led, LOW); //turn led off

   }

 }

משתנים והתניות

זה המקום להסביר מהם משתנים והתניות. כבר דיברנו על משתנים כשיצרנו לולאה אבל שווה לדבר עליהם שוב בגלל החשיבות שלהם. כדי ליצור משתנה אנחנו משתמשים בסימן = . לדוגמה:
int x = 1
int x = 4
int y =6
int z = x + y

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

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

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

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

אפשר לקרוא עוד על התניות באתר ארדואינו:

התניות בארדואינו

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

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

כל פעם שלוחצים על הכפתור המשתנה משנה את מצבו. דבר זה נקרא toggle או שינוי מצב. לא אכפת לנו מה היה המצב הקודם כל מה שאנחנו מעוניינים הוא שהמשתנה יהפוך מצב. את היפוך המצב אנחנו מבצעים ע"י סימן קריאה ! שהופך true ל false ולהפך.

boolean button_state = false;

void setup() {  // put your setup code here, to run once:

    pinMode(11, OUTPUT);

    pinMode(10, INPUT);

}

void loop() {

    if(digitalRead(10) == HIGH){

        delay(200);

        button_state = !button_state;

    if (button_state){

        digitalWrite(11, HIGH);

    } 

  else{

      digitalWrite(11, LOW);

    }

  }

}

 

תקשורת טורית דרך הUSB

תקשורת בין הארדואינו למחשב

לכבל ה USB שמחובר מהמחשב לארדואינו ישנם שתי תפקידים – העברת מתח מהמחשב לארדואינו, במקרה שלנו 5 וולט, והתפקיד השני הוא העברת מידע.

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

הפונקציות שנשתמש בהן בסקיצה זו הן ()Serial.begin – פונקציה המתחילה תקשורת סיריאלית למחשב ומקבלת ערך של קצב העברת סיביות בשנייה במקרה שלנו 9600.

והפונקציה () Serial.println – מדפיסה שורה מהארדואינו לחלון התקשורת הטורית. חברו את הרגל השמאלית של הפוטנציומטר ל GND ואת הימנית ל 5 וולט בארדואינו. חברו את הרגל האמצעית לשקע A0.

 

book-arduino_pot2

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

 void setup() { 

    pinMode(A0,INPUT); 

    Serial.begin(9600);

 } 

void loop() { 

    Serial.println(analogRead(A0)); 

    delay(100);

 }

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

book-serial_pot

 

תקשורת בכיוון ההפוך

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

char data; 

int led = 9; 

void setup() { 

    Serial.begin(9600); // start serial communication 

    pinMode(led, OUTPUT); // set pin 9 to output 

}

 void loop() {

    if(Serial.available() > 0){ // check if we get any data  


        data = Serial.read(); //update the variable data with the //value we get  


  }  


  if(data == '1'){ // if its 1    


    digitalWrite(led, HIGH); // turn led on    

} else if(data == '0'){ // if its 0         


      digitalWrite(led, LOW); // turn led off   


   } // end else if

 } //end loop

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

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

  • אנחנו יוצרים משתנה שנקרא data מסוג char. Char זה תו וזוהי הדרך לקבל מידע מתקשורת טורית. אם נרצה לקבל מספר (int) נצטרך לבצע המרה.
  • הארדואינו בודק ברציפות האם התקבל תו על ידי הפונקציה () serial.available . זוהי פונקציה שמחזירה את מספר התווים בזכרון הזמני של הפתחה.
  • אם הוא גדול מ 0 אנחנו מחלצים אותו מהזיכרון הזמני ומשימים אותו למשתנה data. הוא אוטומטית נמחק מהזיכרון של הפתחה(buffer).
  • כל מה שנותר כעת זה להשוות אותו ל 0 או 1.

 

book-serial_communication


 אוגר הזזה

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

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

השבב שנעבוד איתו הוא SN74HC595N שמקבל 8 ביט נתונים בטור ומוציא אותם במקביל ועל ידי כך נוצרים לנו שמונה ערוצים חדשים להפעלה.

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

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

אוגר הזזה
אוגר הזזה

עכשיו נעבור על החיבורים שלו:

QA-QH הם היציאות אותן אפשר לחבר לנורות מנועים וכו’
VCC כמובן הולך ל- 5V בארדואינו
GND כמובן הולך לאדמה בארדואינו
SER /DATA הוא הפין איתו אנחנו שולחים את הביטים מהארדואינו נחבר לפין 3 בארדואינו
SRCLK / CLOCK הוא תזמון השעון בו גם נשלוט מהארדואינו נחבר לפין 4 בארדואינו
RCLK / LATCH הוא הפין שבפועל שולח את הביטים אל השבב כשהם מוכנים נחבר לפין 2 בארדואינו
OE הוא פין המאפשר פלט ואותו נחבר לאדמה. אם רוצים לדוגמה לכבות ולהדליק את כל הפינים בבת אחת אז אפשר לחבר אותו לפין שליטה בארדואינו
SRCLR מוחק את הביטים מהזכרון כשמורידים אותו לאדמה אבל פה אנחנו לא צריכים את זה אז נעלה אותו ל- HIGH

ככה המעגל הבסיסי צריך להראות:

אוגר הזזה חיבורים
אוגר הזזה חיבורים

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

void setup() {
 pinMode(2, OUTPUT); // RCLK or LATCH
 pinMode(3, OUTPUT); // SER or DATA
 pinMode(4, OUTPUT); // SRCLK or CLOCK

digitalWrite(2, LOW); // turn off shift
 shiftOut(3, 4, LSBFIRST, B01000000); //Shift bits from left to right
 digitalWrite(2, HIGH); //Latch high - commit to shift
 }

void loop() {

}

הפונקציה shiftOut מקבלת 4 ערכים – פין DATA , פין שעון, האם לשלוח את הביטים משמאל לימין או מימין לשמאל ובמקרה שלנו זה משמאל לימין(LSBFIRST) אם היינו רוצים לקרוא מימין לשמאל היינו מכניסים MSBFIRST.
הפרמטר האחרון בפונקציה הוא הביטים שאנחנו שולחים ופה אנחנו קובעים איזה פינים בשבב אנחנו מדליקים ומכבים. את זרם הביטים אנחנו מתחילים עם האות B שאומרת לארדואינו שמדובר בביטים ולא במספרים.

אוגר הזזה נורת לד
אוגר הזזה נורת לד

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

void setup() {
 pinMode(2, OUTPUT); // RCLK or LATCH
 pinMode(3, OUTPUT); // SER or DATA
 pinMode(4, OUTPUT); // SRCLK or CLOCK

}

void loop() {

digitalWrite(2, LOW); // turn off shift
 shiftOut(3, 4, LSBFIRST, B01000000); //Shift bits from left to right
 digitalWrite(2, HIGH); //Latch high - commit to shift

delay(1000);

digitalWrite(2, LOW);
 shiftOut(3, 4, LSBFIRST, B00000000);
 digitalWrite(2, HIGH);

delay(1000);
 }

שלושת הפינים של השליטה 2,3,4 הם שרירותיים ואפשר לבחור בשלושה פינים אחרים.

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

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

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

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

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

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

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

אוגר הזזה 8 נורות
אוגר הזזה 8 נורות

ועכשיו נכתוב את הקוד:

int latchPin = 2;
int clockPin = 4;
int dataPin = 3;
 
byte leds = 0;
 
void setup() {
   pinMode(latchPin, OUTPUT);
   pinMode(dataPin, OUTPUT); 
   pinMode(clockPin, OUTPUT);
}
 
void loop() {
   leds = 0;
   updateShiftRegister(); // refresh and update the shift register
   delay(500); // change to 100 for quick switching
   for (int i = 0; i < 8; i++){ // loop on all bits
      bitSet(leds, i); // arduino function to set bit on or off
      updateShiftRegister();
      delay(500); // change to 100 for quick switching
   }
}
 
void updateShiftRegister(){
   digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, LSBFIRST, leds);
   digitalWrite(latchPin, HIGH);
}
הפעלת 8 נורות לד
הפעלת 8 נורות לד

בשביל אפקט מרשים יותר אפשר להוריד את ההשהייה ל-100 מילישניות ולקבל אפקט מהיר כמו בנורות של שילוט חוצות.


קריאה של חיישנים

בתוך הערכה שקיבלתם יש ארבעה סוגים  של חיישנים:

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

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

חיישן אור

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

חברו רגל אחת של החיישן אל 5 וולט בארדואינו. את הרגל השנייה חברו ל A0. את אותה הרגל חברו לנגד 10k ומשם ל GND.

 

book-ldr_fritzing

עכשיו הכניסו את הקוד:

void setup() {

    Serial.begin(9600);

    pinMode(A0, INPUT);

 }

void loop() {

    Serial.println(analogRead(0));

    delay(1000);

 }

פתחו את חלון התקשורת הטורית – הערך אמור להיות באזור ה 800 אך זה תלוי בתנאי האור בחדר ובערך הנגד.

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

 

void setup() {   

   pinMode(9, OUTPUT); // led pin

   pinMode(A0, INPUT); // light sensor pin

 }

void loop() {

  if(analogRead(A0) < 830){ 

  digitalWrite(9, HIGH); 

} 

else{ 

  digitalWrite(9, LOW); 

} 

delay(1000); 

}

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

חיישן טמפרטורה אנלוגי

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

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

רוב חיישני הטמפרטורה האנלוגיים מגיעים עם משוואה קבועה כדי להמיר את התוצאה שאנחנו מקבלים מהפין האנלוגי ממתח ל טמפרטורה. בחיישן זה: temp = (5.0 * analogRead(tempPin) * 100.0) / 1024 לוקחים את התוצאה המגיעה מהחיישן, מחלקים ב 1024 שזה מספר הערכים של הפין האנלוגי בארדואינו ומכפילים ב 5 וולט שזה המתח שבו הפין האנלוגי עובד.

עכשיו יש לנו תוצאה במילי וולט ונשאר להכפיל אותה ב 100 לפי הוראות היצרן. את הערך שנקבל מהחיישן נשמור במשתנה שנקרא value מסוג float. Float במחשבים הוא שבר עשרוני ומיוצג עם נקודה, כך שגם מספר שלם מיוצג כך – 5.0.

 float value; 

void setup(){ 

  Serial.begin(9600);

} 

void loop(){ 

  value = analogRead(A0); 

  value = value /1024 * 5.0 * 100; 

  Serial.println(value);

  delay(1000);

 }

book-temperature_fritzing

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

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

חיישן טמפרטורה ולחות דיגיטלי

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

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

שימוש בספריות

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

לארדואינו יש ספריות כמעט לכל דבר שתרצו – הפעלת מנועים, GPS , שלט אינפרה אדום ועוד ועוד….

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

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

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

מנהל הספריות של ארדואינו
מנהל הספריות של ארדואינו

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

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

#include "DHT.h"

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

הנה הסבר מפורט על הורדת ספריות:

https://www.arduino.cc/en/Guide/Libraries

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

 

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);

void setup() {  
  Serial.begin(9600);  
  Serial.println("DHTxx test!");
  dht.begin();
}

void loop() {

  // Wait a few seconds between measurements.

  delay(2000);

  float t = dht.readTemperature();

  // Check if any reads failed and exit early (to try again).

  if ( isnan(t)) {

    Serial.println("Failed to read from DHT sensor!");

    return;

   }

  Serial.print("Temperature: ");

  Serial.print(t);

 }

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

חיבורי החיישן

 

blog-dht-11

הפין השמאלי הולך ל 5 וולט בארדואינו, השני הולך לפין דיגיטלי שקולט את המידע, השלישי נשאר ריק והאחרון הולך למינוס בארדואינו. בין הפין השני ל 5 וולט אפשר לחבר נגד בערך של 10K לשיפור בדיוק ובמהירות אך לא חובה.

 

book-dht_11_lm35

 

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

 
#include "DHT.h"

float value;

#define DHTPIN 2 // what digital pin we're connected to

#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);

void setup() {  
  Serial.begin(9600);
  dht.begin();
}

void loop() {

    // Wait a few seconds between measurements.

    delay(2000);

    float t = dht.readTemperature();

   // Check if any reads failed and exit early (to try again).

   if ( isnan(t)) {

     Serial.println("Failed to read from DHT sensor!");

     return;

 }

   value = analogRead(A0);

   value = value /1024 * 5.0 * 100;

   Serial.print("LM35: ");

   Serial.println(value);

   Serial.print("DHT11: ");

   Serial.println(t);

 }

blog-serial_temp

 

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

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

חיישן נטייה

store-tilt_sensor

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

לחיישן בערכה אין קוטביות לכן אין חשיבות לחיבור הרגליים.
כדי לחבר אותו נחבר רגל אחת לפין דיגיטלי 2 ואת השנייה ל GND. במקביל לחיבור לפין הדיגיטלי נחבר נגד 10K שישמש כ PULL UP ויקבע ברירת מחדל לפין הדיגיטלי.

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

 

book-fritzing_tilt

עכשיו נכניס את הקוד הבא:

void setup() {    

  pinMode(2, INPUT); // tilt sesnsor digital read   

  pinMode(13, OUTPUT); // led pin  }

void loop() {  

  if ( digitalRead(2) == HIGH){// if the sensor is tilted      

    digitalWrite(13, HIGH); // turn on led    

    delay(200); // wait 200 milliseconds for stability   

 } else{ // if its not tilted      

     digitalWrite(13, LOW); // turn off led    

     delay(2000) 
    }

}

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

 


מטריצת לדים

בערכה ישנה מטריצת לדים של 8 על 8 שאפשר להדליק ולכבות בה נורות ועל ידי כך ליצור גרפיקה בסיסית וגם לכתוב אותיות ומספרים. הדרך הפשוטה ביותר לשלוט על הנורות היא על ידי ספריית ledcontrol של ארדואינו.
אחרי שמורידים את הספריה למחשב ומחלצים אותה אפשר לגרור אותה לתיקיית הספריות של ארדואינו.
הדרך לשלוט במטריצה היא כמו בכל מטריצה אחרת – אנחנו כותבים באיזו שורה ואיזו עמודה אנחנו רוצים לשלוט ואז מדליקים או מכבים על יד true או false. השורות והעמודות מתחילות מצד שמאל למטה ומגיעות עד מספר 7. זכרו שבמחשבים מתחילים לספור מ 0 ולא מ 1.

חיבורים
למטריצה יש חמישה חיבורים שהם משמאל לימין:
VCC – הולך ל 5V בארדואינו
GND – הולך ל GND בארדואינו
DIN – הפין שמקבל את המידע מהארדואינו. נחבר אותו לפין 12
CS – מתחבר לפין 10 בארדואינו
CLK – הולך לפין 11 בארדואינו

קוד

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

 #include "LedControl.h"
 LedControl lc=LedControl(12,11,10,1);
 void setup() {
 lc.shutdown(0,false);
 lc.setIntensity(0,8);
 lc.setLed(0,0,0,true);

}

void loop() {

}
מטריצת לדים
מטריצת לדים

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

 #include "LedControl.h"
 LedControl lc=LedControl(12,11,10,1);
 void setup() {
 lc.shutdown(0,false);
 lc.setIntensity(0,8);
 lc.setLed(0,7,7,true);

}

void loop() {

}
מטריצת לדים הפעלה
מטריצת לדים הפעלה

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

#include "LedControl.h"
 LedControl lc=LedControl(12,11,10,1);
 void setup() {
 lc.shutdown(0,false);
 lc.setIntensity(0,8);

}

void loop() {

for (int row=7; row>=0; row--) {
 for (int col=0; col<8; col++)
 {
 lc.setLed(0,row,col,true); // turns on LED at col, row
 delay(50);
 }
 }

for (int row=7; row>=0; row--) {
 for (int col=0; col<8; col++)
 {
 lc.setLed(0,row,col,false); // turns on LED at col, row
 delay(50);
 }
 }

delay(1000);

for (int row=0; row<8; row++) {
 for (int col=0; col<8; col++)
 {
 lc.setLed(0,col,row,true); // turns on LED at col, row
 delay(25);
 }
 }

for (int row=0; row<8; row++)
 {
 for (int col=0; col<8; col++)
 {
 lc.setLed(0,col,row,false); // turns off LED at col, row
 delay(25);
 }
 }
 delay(1000);

}
מטריצת לדים לולאות
מטריצת לדים לולאות

ג’ויסטיק אנלוגי

בערכה יש ג’ויסטיק אנלוגי שיכול לשלוט בהתקנים ורכיבים אחרים. לג’ויסטיק יש יכולת לזוז בציר ה x ובציר ה y וגם אפשרות לחיצה ממש כמו עכבר.
נחבר את החיבור השמאלי ל GND חיבור אחד אחריו ל 5V ואת שני החיבורים הבאים לשני פינים אנלוגיים A0 A1.
את החיבור הבא אפשר לחבר לפין דיגיטלי אם רוצים לדמות לחיצה על כפתור.

ג'ויסטיק אנלוגי
ג'ויסטיק אנלוגי

קודם כל נדפיס למסך את הקלט מהרגליים האנלוגיות :

void setup() {
 Serial.begin(9600);

}

void loop() {
 Serial.print("x = ");
 Serial.println(analogRead(A0));
 Serial.print("y = ");
 Serial.println( analogRead(A1));
 Serial.println("------------------");
 delay(1000);
 }

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

אנחנו ניקח את הערכים שמגיעים מהג’ויסטיק (0-1023) ונמיר אותם לערכים של 0-180 שמתאימים להפעלת הסרוו.

#include <Servo.h>
 Servo myservo; // create servo object to control a servo
 // twelve servo objects can be created on most boards
 int pos = 0; // variable to store the servo position
 void setup() {
 Serial.begin(9600);
 myservo.attach(9); // attaches the servo on pin 9 to the servo object
 }

void loop() {
 pos = map(analogRead(A0), 0, 1023, 0, 180);
 myservo.write(pos);
 Serial.println(pos);
 }
ג'ויסטיק וסרוו
ג'ויסטיק וסרוו

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


חיישן תנועה אינפרא-אדום

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

חיישן אינפרה אדום

לחיישן בתמונה יש שלוש רגליים:
GND – הולך ל GND בארדואינו
power – הולך ל5V בארדואינו
OUT – זוהי הרגל שמוציאה פלט ברגע של זיהוי תנועה ומחוברת לרגל דיגיטלית בארדואינו.

arduino-pir-sensor-blog

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

 void setup() {

Serial.begin(9600); //התחל תקשורת טורית

pinMode(2, INPUT); // רגל 2 תחכה לקלט

}

void loop() {

Serial.println(digitalRead(2)); //מדפיס את התוצאה לחלון

delay(1000);// חכה שנייה

}

עכשיו שפותחים את חלון התקשורת אמורים לראות 0 כל שנייה אלא אם כן החיישן מזהה תנועה ואז מודפסת הספרה 1.
מה קורה אם זה לא עובד? אפשר לשחק קצת עם הברגים הצהובים כדי לבדוק אולי פה הבעיה. לבדוק שוב את החיבורים ואולי להחליף את חיבורי 5V /GND בחיישן .

אינפרה תקשורת טורית


ממסר

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

ממסר ארדואינו

– הולך ל GND בארדואינו
+ הולך ל5V או 3.3V בארדואינו
S הולך לרגל 3 בארדואינו
קוד:

 void setup() {

pinMode(2, INPUT);// רגל 2 תחכה לקלט

pinMode(3, OUTPUT);// רגל מדליקה ממסר

}

void loop() {

if(digitalRead(2) == HIGH){//אם מגיע קלט

digitalWrite(3, HIGH);//הדלק ממסר

delay(3000);// חכה 3 שניות זה גם זמן ההשהיה של החיישן

digitalWrite(3, LOW);// כבה ממסר

}

}

relay-pir-blog

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

לכל ממסר יש שלוש יציאות להפעלת התקן חיצוני:
C – זהו חיבור common שהוא כמו מינוס או אדמה, בדרך כלל זהו החיבור האמצעי.
NO – זהו חיבור normally open מה שאומר שאם נחבר התקן לחיבור הזה המעגל יהיה פתוח כברירת המחדל. מעגל פתוח אומר שהוא לא עובד כי אין מגע, ברגע שנפעיל את הממסר הוא יסגור מעגל ואז ההתקן יעבוד. כמעט בכל המקרים נשתמש בחיבור הזה ביחד עם common.
NC – חיבור normally close אומר שהמעגל יהיה סגור כל הזמן(ההתקן יפעל) אלא אם נדליק את הממסר ואז הוא יופסק.
קודם כל נחבר מנורה ל C ו NO כדי להפעיל אותה דרך הממסר.
זהירות מתח גבוה – אם אתם מתחת לגיל 18 או אין לכם נסיון עם מתח גבוה עדיף לדלג על החלק הזה בפרויקט או לנקוט באמצעי זהירות . הנורה מופעלת מ 220V לכן צריך לנתק אותה מהחשמל לפני שמגלפים חוטים. לפני שמכניסים או מוציאים חוטים מהממסר לנתק את הנורה מהשקע.  אסור בשום אופן לגעת בחוטים החשופים כשהנורה מחוברת לשקע.

bulb-220v-wires

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

bulb-220v-open-wires

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

arduino-bulb-relay

כל זה שהמנורה עדיין לא מחוברת לשקע!! מכניסים את החוטים ליציאות הממסר האמצעית והימנית C, NO . מוודאים שהם לא נוגעים אחד בשני עדיף לשים בידוד .
אחרי שהעלנו את הקוד וחיברנו את החוטים לממסר נבדוק שכל החיבורים יושבים כמו שצריך ואז נכניס את הנורה לשקע.
עכשיו המנורה אמורה לעבוד ל 3 שניות בכל פעם שהחיישן מזהה תנועה. אפשר להגדיל את ההשהייה ל 30 שניות ודבר זה טוב נגיד לתאורת חוץ שבה החיישן מפעיל מנורה לזמן קצוב ואז נכבה אחרי שנכנסים לבית.
חוסכים בחשמל
עכשיו אנחנו רוצים לעשות משהו הפוך – אנחנו רוצים לכבות את המנורה כשאף אחד לא נמצא בחדר כדי לחסוך בחשמל, וכל עוד מישהו נמצא בחדר היא אמורה לפעול. בשביל זה נשתמש בבורג הימני שנמצא על החיישן time delay adjust ונסובב אותו עד הסוף מה שיתן לחיישן השהיה של 5 דקות. בנוסף אנחנו צריכים להזיז את הג'מפר הצהוב ל H – repeat trigger. מה שיקרה במצב הזה הוא שהחיישן יזהה תנועה ברגע שמישהו נכנס לחדר, ידליק את הממסר ויכנס להשהיה של 5 דקות ובזמן הזה כל תנועה שתהיה בחדר הוא יאריך את זמן ההשהיה בעוד 5 דקות. אם בכל הזמן הזה לא תהיה תנועה הוא יכבה את הממסר.

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

 void setup() {

pinMode(2, INPUT);

pinMode(3, OUTPUT);

}

void loop() {

if(digitalRead(2) == HIGH){

digitalWrite(3, HIGH);

} else{

digitalWrite(3, LOW);

}

}

arduino-relay-pir-finish

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


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

חיישן מרחק זה הוא מצוין לשימוש ברובוטיקה ומכוניות על שלט רחוק כי הוא נותן לנו לדעת את המרחק מהקיר ומעצמים אחרים.
טווח הזיהוי שלו הוא בין 2 ס"מ ל- 4 מטר והוא פועל על 5 וולט. יש לו שני רמקולים קטנים שמוציאים תדר באורך גל של 40KHz שהאוזן לא יכולה לשמוע והמקלט הפנימי שלו מקבל את החזר הקול ולפי הזמן שעבר בין יציאת התדר לחזרתו אנחנו יכולים לחשב את המרחק.
אנחנו יודעים מהי מהירות הקול שהיא נתון קבוע ולכן הזמן שעבר בין השליחה לחזרה נותן לנו לחשב את המרחק. מרחק = זמן x מהירות.
אלה החיבורים של החיישן:
VCC הולך ל- 5V בארדואינו
GND הולך ל- GND בארדואינו
TRIG מתחבר לפין פלט בארדואינו שמוציאה את התדר נחבר לפין 2 בארדואינו
ECHO מתחבר לפין בארדואינו שמחכה להחזר התדר נחבר לפין 3 בארדואינו

int duration;
int distance;
void setup() {
    pinMode(2, OUTPUT); // Sets the TRIG pin as an Output
    pinMode(3, INPUT); // Sets the ECHO pin as an Input
    Serial.begin(9600); // Starts the serial communication
}
void loop() {
    // Clears the trigPin
    digitalWrite(2, LOW);
    delayMicroseconds(2);
    // Sets the trigPin on HIGH state for 10 micro seconds
    digitalWrite(2, HIGH);
    delayMicroseconds(10);
    digitalWrite(2, LOW);
   // Reads the echoPin, returns the sound wave travel time in microseconds
    duration = pulseIn(3, HIGH);
   // Calculating the distance
    distance= duration * 0.01715; // speed of sound divided by 2
   // Prints the distance on the Serial Monitor
    Serial.print("Distance: ");
    Serial.println(distance);
    delay(1000);
}
חיישן אולטראסוני חיבורים
חיישן אולטראסוני חיבורים
מרחק מוחזר בסנטימטר
מרחק מוחזר בסנטימטר

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

תצוגת ספרות 7 מקטעים

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

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

חיבורי תצוגת לד

book-7segment_display

נחבר את הפינים a-g לפינים דיגיטליים 2-8 בארדואינו לפי הסדר שלהם, ואת אחד הפינים של ה com נחבר לGND עם נגד של 220 אוהם או 1K.

 

book-fritzing_display

 

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

כדי להציג ספרה פשוט נדליק את הפינים המתאימים… להראות את הספרה 8 אפשר להדליק את כל המקטעים:

 

void setup(){   

  pinMode(2, OUTPUT);  

  pinMode(3, OUTPUT);  

  pinMode(4, OUTPUT);

  pinMode(5, OUTPUT);  

  pinMode(6, OUTPUT);

  pinMode(7, OUTPUT);

  pinMode(8, OUTPUT);

  digitalWrite(2, HIGH);  

  digitalWrite(3, HIGH);

  digitalWrite(4, HIGH);

  digitalWrite(5, HIGH);

  digitalWrite(6, HIGH);  

  digitalWrite(7, HIGH);   

  digitalWrite(8, HIGH);

}
void loop(){}

 

שימוש בלולאות

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

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

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

void setup(){  

  for ( int pin = 2 ; pin < 9 ; pin++){ // setup pins 2 – 8 to be output   

    pinMode(pin, OUTPUT);
 }   


 for ( int pin = 2 ; pin < 9 ; pin++){ // turn on pins 2 - 8    

   digitalWrite(pin, HIGH);  

   }

}

 void loop(){}

מה שקורה בלולאה זה שהמשתנה שנקרא pin רץ מהמספר 2 עד 8 ומכין את הפינים האלה ולאחר מכן גם מפעיל אותם. מזל שיש לנו לולאות!!!.

באותו אופן שהצגנו את המספר 8 אפשר להציג כל מספר אחר מ 0-9. אבל איך נדע כל פעם איזה פינים להדליק? אפילו אם אנחנו יודעים למשל שכדי לקבל את הספרה 4 צריך להפעיל את פינים 3 4 7 ו 8 , איך נזכור את זה ואיך נעשה סדר בבלגן?

שימוש במערך

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

 String bag[] = {"wallet", "phone", "book"};

אחרי שיצרנו את התיק אפשר לגשת אליו ולשלוף ממנו חפצים:

 Serial.println(bag[0]);

 

זה ישלוף את הערך הראשון שהוא ארנק. הערך השני bag[1] הוא טלפון, והשלישי bag[2] הוא ספר. למה מתחילים לספור מאפס ולא מאחד? זוהי מין מסורת כזו של מתכנתי מחשבים.
כשיוצרים את המערך צריך להצהיר מראש איזה סוג של ערכים יהיו בו – מחרוזות, מספרים או סוג אחר:

String bag[] = {"wallet", "phone", "book"}; // a bag full of stuff

 int lottery[] = {2, 35, 14, 22, 17, 9}; // the winning lottery numbers

 void setup(){ 


   Serial.begin(9600);   


   Serial.println(bag[0]); // print the first item in bag array (wallet)

  Serial.println(lottery[1]); // print the second item in lottery array (35)

 }

void loop(){}

 

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

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

 

int zero[] = {6,2,3,4,5,6,7};

 int one[]= {6, 7};

 int two[] = {2,3,5,6,8};

 int three[] = {2, 3, 4 ,5, 8};

 int four[] = {3,4,7,8};

 int five[] = {2,4,5,7,8};

 int six[] = {2,4,5,6,7,8};

 int seven[] = {2,3,4};

 int eight[] = {2,3,4,5,6,7,8};

 int nine[] = {2,3,4,7,8};

 

עכשיו אנחנו יכולים להציג בקלות כל ספרה שאנחנו רוצים ע"י שתי לולאות רצופות:

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

 

for (int i = 0 ; i < sizeof (five) / 2 ; i++ )
    digitalWrite(five[i], HIGH);

 

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

החלק החשוב בלולאה הוא השורה שבה אנחנו ניגשים למערך five שיצרנו ומוציאים בכל פעם איבר אחר לפי הסדר עד שאנחנו מסיימים. בסיבוב הראשון הפקודה היא five[0] כי i שווה אפס וכן הלאה.

עכשיו החלטנו שאנחנו רוצים ליצור ספירה לאחור מ 9 ועד 0 כשהספרה מתחלפת כל שנייה איך נעשה זאת? הדרך הארוכה והמסורבלת היא להפעיל את את ספרה 9 לחכות שנייה ואז לכבות אותה ולהפעיל את ספרה 8 וכן הלאה.

פונקציות בארדואינו

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

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

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

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

// create new function with a parameter named number  and type array

void displayNumber(int number[]){

     for ( int i = 0; i < 8; i++){

        if (number[i] > 0) // if pin number is bigger than 0     

            digitalWrite(number[i], HIGH); // turn on pin

   }

 }

וזוהי הפונקציה שמוחקת את הספרה מהמסך:

void clearDisplay(){   

  for (int i = 2 ; i < 9 ; i++)     

    digitalWrite(i, LOW);

 }

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

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

int nine[] = {2,3,4,7,8,0,0};

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

הקוד המלא

int zero[] = {6,2,3,4,5,6,7};

 int one[]= {6, 7,0,0,0,0,0};

 int two[] = {2,3,5,6,8,0,0};

 int three[] = {2, 3, 4 ,5, 8,0,0};

 int four[] = {3,4,7,8,0,0,0};

 int five[] = {2,4,5,7,8,0,0};

 int six[] = {2,4,5,6,7,8,0};

 int seven[] = {2,3,4,0,0,0,0};

 int eight[] = {2,3,4,5,6,7,8};

 int nine[] = {2,3,4,7,8,0,0};

void setup(){  

  pinMode(13, OUTPUT);

    for ( int i = 2 ; i < 9 ; i++){

      pinMode(i, OUTPUT);   
   }
}

void loop(){  
  displayNumber(nine);   
  clearDisplay();   
  displayNumber(eight);
  clearDisplay();  
  displayNumber(seven);
  clearDisplay();    
  displayNumber(six);  
  clearDisplay();
  displayNumber(five);
  clearDisplay();
  displayNumber(four);
  clearDisplay();   
  displayNumber(three);
  clearDisplay();  
  displayNumber(two);  
  clearDisplay();  
  displayNumber(one);
  clearDisplay();
  displayNumber(zero);  
  clearDisplay();    
  tone(13, 300, 1000);   
  delay(2000);
}

 // functions

void displayNumber(int number[]){  

  for ( int i = 0; i < 7 ; i++){

    if (number[i] > 0){

      digitalWrite(number[i], HIGH);   

    }

}  

   tone(13, 600, 40);

   delay(1000);  
}

void clearDisplay(){   

  for (int i = 2 ; i < 9 ; i++)

     digitalWrite(i, LOW);
}

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

 

book-disply_pot_buttons

 

תצוגת 4 ספרות

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

תצוגת מקטעים 4 ספרות
תצוגת מקטעים 4 ספרות

D1, D2, D3, D4 הם הרגליים שמפעילות את הספרות. כל שאר הרגליים מפעילות את שבעת המקטעים של כל ספרה.
חיווטים וקוד
אפשר לכתוב קוד שמפעיל מקטעים וספרות בצורה ידנית אבל הרבה יותר נוח במקרה הזה להשתמש בספריית ארדואינו sevseg.
בספריה הזו מכניסים את הרגליים בהם משתמשים ואז אפשר לרשום מספר שיוצג על הלוח וגם לנקות אותו. לפי הספריה אלו החיבורים שצריך לבצע:
D1 – פין 2 בארדואינו
D2 – פין 3 בארדואינו
D3 – פין 4 בארדואינו
D4 – פין 5 בארדואינו
A – פין 6 בארדואינו
B – פין 7 בארדואינו
C – פין 8 בארדואינו
D – פין 9 בארדואינו
E – פין 10 בארדואינו
F – פין 11 בארדואינו
G – פין 12 בארדואינו
decimal – פין 13 בארדואינו

#include <SevSeg.h>
 SevSeg sevseg;

void setup(){

byte numDigits = 4;
 byte digitPins[] = {2, 3, 4, 5};// Digits: 1,2,3,4
 byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13}; //Segments: A,B,C,D,E,F,G,Period
 sevseg.begin(COMMON_ANODE, numDigits, digitPins, segmentPins);
 sevseg.setBrightness(90);
 }

void loop(){

sevseg.setNumber(1258,0);
 sevseg.refreshDisplay(); // Must run repeatedly; don't use blocking code

}

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


מקורות כח

 

 

book-arduino-power

 

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

מתח מומלץ לספק הוא 9 עד 12 וולט. אם משתמשים בבטריה מומלץ לספק 9 וולט ולחבר ל VIN ו GND אם ממתקן הבטריה יוצאים שתי חוטים או לחבר לשקע הסטנדרטי אם קיים במתקן הבטריה.

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

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


כל הזכויות שמורות להאקסטור – 2016

35 thoughts on “מדריך ארדואינו למתחילים חלק א'”

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

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

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

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

  3. שלום, תודה על ההסבר הברור כלכך!
    אני עושה פרוייקט באלקטרוניקה שכולל תצוגת 7 מקטעים ואני משתמשת במפתח PORT D. זה עובד מצויין אבל משום מה המקטעים a ו b נדלקים גם כאשר אני שולחת להם 0 לוגי. חשוב לציין שאני מקפידה להוציא לפני הצריבה לארדואינו את ההדקים האלו כדי לא להשפיע על התקשורת הטורית. אשמח מאוד לשמוע אם יש משהו שאני יכולה לעשות בנידון.
    תודה מראש!

    1. שלום.
      קשה לומר בלי לראות קוד וחיבורים, יכול להיות שיש איזו שורה בהמשך שמדליקה אותם מחדש.
      בדוגמה בספר הם מחוברים לפינים 2 ו-3 בארדואינו כך שאם לא מדליקים את הפינים הם לא אמורים לעבוד.
      דרך אגב לדעתי אין צורך להוציא הדקים לפני הצריבה שכן אף אחד לא מחובר ל-0(rx) או 1(tx) .

  4. בתכנית הספציפית שלי אני חייבת להשתמש ב rx ו tx בגלל שאני משתמשת בport d וזה רק על הדקים 0-7 אז אין לי ברירה. אני רוצה ׳לחסוך׳ בהדקים וגם לא לעשות תכנית של מערכים אם הדרך של port זה כל כך קצר..
    הקוד שכתבתי הוא גם לא ישיר לתצוגה, זה על פי לחצנים: יש 4 לחצנים ואם כולם לא לחוצים התצוגה מראה את הספרה 4 אם 1 לחוץ ו3 לא אז היא מראה 3.. וזה עובד ממש יפה חוץ מההדקים הללו שמוסיפים תאורה בזמן הלא נכון….

  5. זה נורא מוזר כי כשאני עושה תכנית קצרה להפעיל את אותה פקודה שמפעילה ספרה 4 לדוג זה לא מפעיל את a והעתקתי בדיוק מהתכנית לתכנית ארדואינו חדשה):

  6. תורידי מהקוד את serial.begin וגם serial.print כי אי אפשר גם תקשורת טורית וגם שימוש בפינים 0 ו-1.

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

  8. בקוד שמתעסק עם חיישן טמפרטורה ולחות דיגיטלי צריל להוסיף את ספריית Adafruit_Sensor בשביל שיפעל.

    1. השורה include DHT.h מוסיפה את הספריה ויש גם הסבר איך להתקין אותה מסביבת הפיתוח לא? או שאני לא מבין אותך כי אצלי זה עובד.

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

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

    🙂

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

  12. אתחיל בזאת : אני חייב לציין את המדריך המעולה ואת העזרה שאתה נותן וכמובן את התגובות החמות אני שמח שהגיע לבלוג כל הכבוד !!
    אני כרגע נמצא בשלבים הראשונים של הפרוייקט ואני נמצא מול אתגר של חיבור 24 LED מסוג : RGB LED Bead IC Built-IN APA106
    כאשר אני רוצה לשלוט על כל אחד בנפרד כולל עוצמת אור וצבע ויכולת להפעיל אחד אחד ,קבוצה קבוצה או כולם !!
    ו12 מנועי Stepper moror Bipolar , שעליהם אני צריך לשלוט בגיוון ובמהירות .
    ואני רוצה לחברם לUno Arduino.
    להלן מספר דברים שאני למדתי :
    1. אני חייב ספק כח נפרד לטובת כל הכמודת של הרכיבים .
    2. אני חייב L298N Dual Motor Controller Modules and Arduino או דומה כדי לחבר כל מנוע
    מפה אני קצת מבולבל ..חח ואשמח לקבל הכוונה
    אני חושב על Multiplexing אני מבין שעדיף להשתמש ב- SPI ולא I2C כי הוא יותר מהיר ואפשר לתת מספר פקודות במגביל .
    אני חושב שלגבי הלדים יש פתרון מובנה IC Built-IN שיכול לקבל פולס דיגיטאלי ולשנות את עוצמות האור .(האם אני צודק ? )
    אין לי כרגע פתרון לגבי המנוע !
    אשמח לעזרה
    מצטער על אורך הפוסט ניסיתי להיות כמה שיותר מדוייק ולתת רקע לפני השאלות .
    תודה מראש על תשובתכם .

    1. שלום. הרעיון בנורות נאו-פיקסל הוא שאפשר לשרשר אותן ולשלוט בכולם דרך פרוטוקול I2C כך שהן דורשות רק שתי יציאות. יש המון קוד ברשת למרות ששלך לא בדיוק מקוריות זה עובד עם אותו שבב WS2812 . הייתי ממליץ על נאו-פיקסל מקורי כמו https://www.adafruit.com/product/1734 כדי להמנע מבלבול והעלאת נורות בעשן, בקרוב הם יהיו פה בחנות.
      לגבי מנועי צעד אתה צריך 48 יציאות – 4*12 . אפשר עם ארדואינו מגה זה הכי פשוט, כמובן אפשר גם עם אונו להרחיב את מספר ההדקים אבל זה יותר מסובך.

      לגבי ספק כח נפרד אפשר לדעתי 5 אמפר זה מספיק…

  13. היי
    ראשית המון תודה 🙂
    אני מתלבט לגבי Multiplexing אם הכל עובד על DIGITAL PIN למעט המהירות של המנוע שאפשר לקבע אותה בשורת קןד 1 (וזה בסדר מבחינת הפרוייקט )
    האם אפשר לדעתך על אותו מטריצה לשלוט ב-LED ובמנועים ( IN1,IN2,IN3,IN4 ) ?
    ואז זה הרבה יותר פשוט ?
    אשמח לתשובותכם 🙂
    הרבה תודה
    אורן

כתיבת תגובה

האימייל לא יוצג באתר.