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

פרקים:

1. מנועים
2. תקשורת I2C ו- SPI
3. מסך LCD
4. לוח מקשים
5. תקשורת אינפרה אדום
6. תקשורת בלוטוס
7. תקשורת אינטרנט
8. כרטיס זכרון
9. מגיני הרחבה
10. תזמונים השהיות ופסיקות

---

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

מנועים

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

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

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

לכל פין של הארדואינו יש מגבלת זרם של 40 מיליאמפר לערך, וכל הבקר בעצמו (ATmega328) אינו יכול לספק יותר מ- 200 מיליאמפר. כניסת המתח של ה- USB יכולה לספק פחות או יותר 750 מיליאמפר שזהו הסטנדרט של USB 3.0 , וחיבור דרך בטריה יכול לספק כמה זרם שהבטריה מסוגלת וזה משתנה מבטריה לבטריה וכך גם לגבי ספקי כח – לדוגמה ספק כח של 5V 1A יכול לספק עד 1 אמפר.

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

מנועי DC

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

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

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

טרנזיסטור

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

לטרנזיסטור יש 3 פינים: כשאנחנו מעבירים זרם בפין מסוים שנקרא BASE נסגר מעגל בין 2 הפינים הנותרים EMITTER ו- COLLECTOR וזרם יכול לעבור בהם ממקור הכח החיצוני. ישנו רף מינימלי של זרם להפעלת הטרנזיסטור, וכן רף מקסימלי בו מותר להשתמש ועליהם ניתן לקרוא במפרט הטכני שלו.

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

 

טרנזיסטור פופולרי הוא 2n3904 שהומצא בשנות ה- 60 ועדיין עושה את העבודה גם היום. אל הפין האמצעי(BASE) הולך הפין של ארדואינו, אל הפין הימני(COLLECTOR) הולך מקור הכח החיצוני והפין השמאלי הולך ל- GND משותף עם הארדואינו והבטריה.

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

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

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

דיודה

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

קבל

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

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

הפעלת מנוע בכיוון אחד

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

 

קוד:

void setup(){ 
  pinMode(A0, INPUT); // potentiometer
  pinMode(9, OUTPUT); // pin that goes to BASE pin in the transistor
}

void loop(){
  analogWrite(9, map(analogRead(0), 0, 1023, 0, 255));
}

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

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

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

 

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

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

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

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

שליטה בכיוון המנוע

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

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

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

הוא נועד להקל עלינו את העבודה ויש לו בדרך כלל שתי שורות שהאריזה שלהם נקראת DIP עם פינים שיוצאים ויכולים להתחבר למטריצה או לוח הלחמה. L293D הוא שבב H-BRIDGE פופולרי עם 16 יציאות דיפ שיכול להפעיל שני מנועים בשני כיוונים שונים.

חיבורים:

• ENABLE1 – פין שמדליק ומכבה את מנוע 1 ושולט גם במהירות המנוע(PWM). בדוגמה הוא הולך לפין 11 בארדואינו
• INPUT1 – פין ששולט בכיוון מנוע 1. בדוגמה הוא הולך לפין 10 בארדואינו
• OUTPUT1 – יציאה למנוע 1
• GND – הולך לאפס משותף עם הארדואינו
• OUTPUT2 – הולך לצד השני של מנוע 1
• INPUT2 – פין שליטה בכיוון מנוע  2 – בדוגמה הולך לפין 9 בארדואינו
• VS – מקור כח חיצוני מבטריה או ספק
• VSS – לוגיקת מתח של 5V. הולך ל- 5V בארדואינו

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

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

מנועי צעד

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

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

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

אלו החיבורים:

• מחברים את 5 החוטים של המנוע אל השקע הלבן במודול.
• מחברים את פינים 8,9,10,11 בארדואינו אל ארבעת החיבורים במודול in1, in2, in3, in4.
• מספקים כח חיצוני על ידי ספק או בטריה ומחברים ל + ו – במודול. מנוע זה עובד על 5V.
• מעלים את הקוד לארדואינו.

const int s1 = 8;
const int s2 = 9;
const int s3 = 10;
const int s4 = 11;
int motorSpeed = 1500; // motor speed between 1000-4000. small number is bigger speed 
void setup() { 
 pinMode(s1, OUTPUT); 
 pinMode(s2, OUTPUT); 
 pinMode(s3, OUTPUT); 
 pinMode(s4, OUTPUT); 
}

void loop() {
  for (int i=0; i<=509; i++){ // go forward one circle, 509 steps
    forward();
  }
  for (int i=0; i<=509; i++){ // go back one circle. 
    back();
 }
}

void motorOff(){ // turn off motor
 digitalWrite(s1, LOW); 
 digitalWrite(s2, LOW); 
 digitalWrite(s3, LOW); 
 digitalWrite(s4, LOW); 
}

void back(){ // function to move 1 step back
  digitalWrite(s1, HIGH); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, HIGH); 
  digitalWrite(s2, HIGH); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, HIGH); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, HIGH); 
  digitalWrite(s3, HIGH); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, HIGH); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, HIGH); 
  digitalWrite(s4, HIGH); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, HIGH); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, HIGH); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, HIGH); 
  delayMicroseconds(motorSpeed);
}

void forward(){ // function to move 1 step forward
  digitalWrite(s1, HIGH); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, HIGH); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, HIGH); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, HIGH); 
  digitalWrite(s4, HIGH); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, HIGH); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, HIGH); 
  digitalWrite(s3, HIGH); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, LOW); 
  digitalWrite(s2, HIGH); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, HIGH); 
  digitalWrite(s2, HIGH); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
  digitalWrite(s1, HIGH); 
  digitalWrite(s2, LOW); 
  digitalWrite(s3, LOW); 
  digitalWrite(s4, LOW); 
  delayMicroseconds(motorSpeed);
}

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

 

NEMA

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

המנוע בתמונה הוא NEMA17 מה שאומר שרוחב המנוע והגובה שלו הם 42.3 מ”מ. העומק שלו יכול להשתנות ממנוע למנוע וכך גם המתח הזרם והמהירות, אבל ריבוע שטח הפנים תמיד יהיה 42×42 מ”מ. המרווח בין הברגים תמיד יהיה 31 מ”מ וקוטר הבורג M3.

מנועי צעד מתחלקים למנועים ביפולריים(Bipolar) ורב-פולריים(Unipolar). מנועים ביפולריים הם יותר נפוצים ומסוגלים לספק יותר מומנט, יש להם רק ארבעה חוטים ולכן יש צורך בדוחף מנוע שיכול לשנות את כיוון המנוע. למנועים רב פולריים יש 5,6 או 8 חוטים ויש צורך רק בטרנזיסטורים להפעילם, כמו שהפעלנו בדוגמה למעלה עם ULN2003.

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

360/1.8=200

מנועי סרוו

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

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

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

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

 

קוד:

#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() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
   // in steps of 1 degree
     myservo.write(pos); // tell servo to go to position in variable 'pos'
     delay(15); // waits 15ms for the servo to reach the position
   }
   for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
     myservo.write(pos); // tell servo to go to position in variable 'pos'
     delay(15); // waits 15ms for the servo to reach the position
   }
}

סיכום מנועים

מנועי DC

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

מנועי צעד:

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

מנועי סרוו:

• מהירות בינונית
• מחיר בינוני
• קלים לתפעול
• מדויקים יחסית

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

דוחפי ובקרי מנוע

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

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

---

 

תקשורת I2C ו SPI

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

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

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

• SPI הוא בדרך כלל מהיר יותר
• SPI נחשב פחות מתוחכם אבל עם זאת יותר פשוט להפעלה
• SPI דורש יותר חוטים מ I2C
• I2C דורש רק 2 חוטים לתקשורת
• I2C יכול להיות יותר מסובך להפעלה מבחינת תכנות
• I2C דורש 2 נגדי PULL UP על חוטי העברת המידע

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

 

שימו לב לשני הנגדים המחוברים בתקשורת I2C וגם לכמות החוטים הגבוהה יותר ב-SPI.

הארכיטקטורה של I2C היא של master ו- slave כשהארדואינו הוא ה master שמתחיל תקשורת עם רכיבים שנקראים slave והתקשורת נעשית באמצעות שתי חוטים :

SDA – אחראי להעברת נתונים בין הארדואינו לרכיבים האחרים. בארדואינו אונו זהו פין אנלוגי A4

SCL – קו שעון שאחראי לתזמון של העברת הנתונים. בארדואינו אונו זהו פין אנלוגי A5

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

• הארדואינו שולח ביט להתחלת תקשורת
• הארדואינו שולח כתובת של 7 ביט שמופנית לאחד הרכיבים
• הארדואינו שולח קריאה(0) או כתיבה(1) כדי להגדיר את הפעולה שברצונו לעשות
• הרכיב שולח חזרה ביט שקיבל את הודעה
• הארדואינו כותב או קורא מהרכיב על ידי שליחת בייט אחד אחרי השני, הרכיב מודיע שקיבל את הבייט אחרי כל שליחה
• הארדואינו שולח ביט לסגירת תקשורת

ישנה ספריה בסביבת העבודה של ארדואינו שנקראת wire שמקלה על התקשורת ונהוג להשתמש בה כשמשתמשים ב- I2C:

https://www.arduino.cc/en/Reference/wire

 

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

• SCLK – קו שעון תזמון משותף לכל הרכיבים
• MOSI – מידע שיוצא מ- MASTER(ארדואינו במקרה שלנו) ומגיע ל- SLAVE(הרכיב)
• MISO – מידע שיוצא מהרכיב ומגיע לארדואינו
• SS – בחירת רכיב. כשישנם כמה רכיבים מחוברים במקביל ישנו חיבור ייחודי לכל אחד שנקרא SLAVE SELECT

החיבורים לארדואינו אונו הם בפינים 11,12,13 וזה אפשרי גם לחבר דרך חיבורי ה- ICSP(ששת החיבורים הבודדים) , דבר שמקל על חיבור מגינים. ישנה ספרייה ייעודית בארדואינו שנקראת SPI. עוד מידע על SPI :

https://www.arduino.cc/en/Reference/SPI

---

 

מסך LCD

מסך LCD מסוג 1602A הוא מסך פופולרי לתצוגה בסיסית של 16×2 אותיות ולמרות שיש המון סוגים שלו רובם עובדים באותה צורה ומבוססים על בקר HITACHI HD44780. אפשר לזהות אותם בדרך כלל על ידי מספר הפינים שהוא 16.

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

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

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

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

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

הסבר על הפינים של 1602A:

1. VSS – פין שהולך לאפס
2. VDD – מתח לוגיקה ,הולך ל- 5V
3. V0 – שליטה בבהירות המסך, הולך לפוטנציומטר
4. RS – אפשרות לבחור בין קלט מידע או הוראות(פקודה או אות), הולך לפין 12 בארדואינו ונשלט על ידי התוכנה
5. R/W – לקרוא או לכתוב לשבב, הולך לאפס(לכתוב)
6. להתחיל הפעלת אות, הולך לפין 11 בארדואינו
7. D4,D5, D6, D7 הולכים לפינים 5,4,3,2 בארדואינו, בעזרת התוכנה אפשר להשתמש ב 4 פינים בלבד במקום ב 8 להעברת מידע.
8. ארבעת הפינים הנותרים D0, D1, D2, D3 נשארים ריקים.
9. A – הולך ל- 5V
10. K – הולך לאפס. שתי הפינים האלה הם אור אחורי של המסך ורצוי לחבר אותם עם נגד.

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

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

 

הנה הדרך לחבר את המסך לארדואינו:

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

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

אחרי זה נתחיל את המסך עם הגודל המתאים:

lcd.begin(16, 2);

לאחר מכן אפשר פשוט לכתוב למסך על ידי :

lcd.print("");

ולזוז בין הריבועים השונים על ידי ע”י:

lcd.setCursor();

כשהפרמטר הראשון הוא מספר עמודה והשני מספר שורה.

שימוש במסך LCD הוא שימושי ביותר ואפשר לחשוב על עשרות שימושים שאפשר לעשות בו:

• להציג מידע מחיישנים שונים
• להציג חיווי על נתונים כמו זרם או מתח
• להציג שעה ותאריך

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

 

קוד:

#include <LiquidCrystal.h>
char message1[13] = "Arduino Game"; //opening messages for the game
char message2[16] = "Answer question";
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // create object with the same pins we connected and name it lcd
void setup() {
  pinMode(8, INPUT); // button 1
  pinMode(9, INPUT); // button 2
  pinMode(7, OUTPUT); // buzzer
  digitalWrite(10, HIGH); //set reset pin to high 
  pinMode(10, OUTPUT); // initialize reset pin
  lcd.begin(16, 2); // start lcd with character size 16x2
  for(int i=0; i < 12; i++){ // show message character by character
    lcd.print(message1[i]);
   delay(300);
   }
  delay(200);
  lcd.setCursor(0, 1); // move to second row
  for(int i=0; i < 15; i++){
    lcd.print(message2[i]);
   delay(300);
   }
 delay(1000);
}
void loop() {
lcd.clear();
lcd.print("14 x 8 = ");
lcd.setCursor(0, 1);
lcd.print(" 112 122");
lcd.setCursor(15, 0);
for(int i = 10; i > 0; i--){ // run 10 seconds until a button is pressed
  tone(7, 700, 80);
  lcd.print(i);
delay(1000);
if ( digitalRead(9) == HIGH){
   lcd.clear();
   lcd.print("Correct Answer!");
   tone(7, 900, 800); // correct tone
   delay(4000);;
   digitalWrite(10, LOW); // reset program to beginning
 }
 else if ( digitalRead(8) == HIGH){
   lcd.clear();
   lcd.print("Wrong Answer");
   tone(7, 200, 150); // wrong tone
   delay(4000);
   digitalWrite(10, LOW); // reset program to beginning
   }
  lcd.setCursor(15, 0);
 }
 lcd.clear();
 lcd.print("Too Slow!!!");
 tone(7, 200, 150);
 delay(1000);
}

מסך LCD I2C

כאמור מסך זה משתמש רק בארבעה חיבורים שנמצאים בגב המסך –
VCC, GND SCL, SDA
יש גם פוטנציומטר לחדות המסך שאפשר לכוון.
כבר למדנו על תקשורת בפרוטוקול I2C ובמקרה הזה היא עושה לנו את החיים קלים. פשוט נחבר את SDA לפין אנלוגי A4 ואת SCL לפין אנלוגי A5.
הקוד להפעלת המסך צריך להתחיל תקשורת I2C עם המסך בצורה הבאה והמסך שאנחנו עובדים איתו ניתנה לו הכתובת 0x27. יש גם צורך להתקין את ספריית LiquidCrystal_I2C ואותה אפשר להוריד מתוך סביבת הפיתוח – סקיצה > הוסף ספרייה > ניהול ספריות ושם להקליד את השם שלה ולהוריד.

#include "Wire.h" // i2c library
 #include <LiquidCrystal_I2C.h> // lcd_i2c library
 LiquidCrystal_I2C lcd(0x27,16,2); // i2c address, rows,columns

void setup(){
 lcd.init(); // initialize screen
 lcd.backlight(); // turn backlight on
 lcd.print("hello world");
 lcd.setCursor(0,1); // move to second row
 lcd.print("Arduino LCD I2C");
 }
 void loop(){}

---

לוח מקשים

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

בוא נניח שאנחנו רוצים ליצור מערכת של בקרת כניסה על ידי מנעול אלקטרוני. ללוח מקשים זה ישנם 7 כניסות – ארבעת הכניסות הראשונות הם השורות ונחבר אותם לפינים 2-5 ואת העמודות נחבר ל 6-8. הספריה Keypad משייכת את המקשים לתגובת הפלט שאנחנו רוצים לראות .

 

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

הפין של הארדואינו אינו יכול לספק זרם מספיק למנעול כי המנעול דורש 330mA בעוד הפין יכול לספק רק 40mA. לכן נשתמש בטרנזיסטור tip120 למרות שאפשר גם להשתמש בממסר. מקור הכח שנספק למנעול הוא 12V DC ממנו אפשר גם לספק כח לארדואינו.

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

חיבורים:

• צריך לספק למעגל מקור כח של 12V עם לפחות 500mA
• פין 13 בארדואינו יפעיל טרנזיסטור דרך נגד 220 שיקשר בין מקור הכח למנעול החשמלי.
• פין 12 בארדואינו יחובר לזמזם שישמיע צפצוף בכל פעם שלוחצים על כפתור, ובנוסף ישמיע זמזום שמח או עצוב בהתאם לססמה

 

קוד:

#include <Keypad.h>
 #define Password_Length 5 // Give enough room for 4 chars + NULL char
 char Data[Password_Length]; // 4 is the number of chars it can hold + the null char = 5
 char Master[Password_Length] = "1234"; // the password
 byte data_count = 0, master_count = 0;
 bool Pass_is_good;
 char customKey;
 const byte ROWS = 4; //four rows
 const byte COLS = 3; //three columns
 char keys[ROWS][COLS] = {
 {'1','2','3'},
 {'4','5','6'},
 {'7','8','9'},
 {'*','0','#'}
 };

byte rowPins[ROWS] = {2,3,4,5}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {6,7,8}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
void setup(){
   Serial.begin(9600);
   pinMode(13, OUTPUT); // goes to BASE in transistor
   pinMode(12, OUTPUT); // goes to buzzer
 }

void loop(){
   customKey = keypad.getKey(); // save pressed key in variable
   if (customKey){ // makes sure a key is actually pressed, equal to (customKey != NO_KEY)
      tone(12, 600, 40); // pressing tone
      Data[data_count] = customKey; // store char into data array
      Serial.println(Data[data_count]); // print char at said cursor
      data_count++; // increment data array by 1 to store new char, also keep track of the number of chars entered
     }
   if(data_count == Password_Length-1){ // if the array index is equal to the number of expected chars, compare data  to master
     Serial.println("Password is ");
   if(!strcmp(Data, Master)){ // equal to (strcmp(Data, Master) == 0)
     Serial.println("Good");
     clearData();
     tone(12, 800, 40); // make happy tone
     delay(100);
     tone(12, 900, 40);
     digitalWrite(13, HIGH); // open the electric lock for 3 seconds 
     delay(3000);
     digitalWrite(13, LOW);
   } 
   else{
     tone(12, 90, 500); // make sad tone if password is not correct
     Serial.println("Bad");
     clearData();
   }
  }
 }

void clearData(){
   while(data_count !=0){ // This can be used for any array size, 
   Data[data_count--] = 0; //clear array for new data
   }
 return;
 }

---

תקשורת אינפרה אדום

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

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

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

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

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

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

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

חיבורים:

• מנוע אחד מתחבר ל- OUT1 ו- OUT2
• מנוע שני מתחבר ל- OUT3 ו- OUT4
• IN1, IN2, IN3, IN4 הולכים לפינים 4, 5, 7, 8 בארדואינו
• EN1 הולך לפין 6 ו- EN2 הולך לפין 9 בארדואינו. אלה הם פינים ששולטים במהירות וצריך להוציא ג’מפרים כדי לחבר אותם.
• המודול רסיבר אינפרה אדום מתחבר ל- GND , 5V ו- S מתחבר לפין 11 בארדואינו
• מקור כח חיצוני 12V מתחבר ל- 12V ול- GND בדוחף המנוע.

 

 

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

הפונקציות פה הם די פשוטות – אם רוצים לדוגמה לסובב את מנוע 1 מפעילים את פין IN1 ומכבים את פין IN2. שליטה במהירות נעשית על ידי EN1 שמופעל על ידי פין PWM 6 בארדואינו. אם רוצים לשנות את הכיוון של מנוע 1 מכבים את פין IN1 ומדליקים את IN2.

#include "IRremote.h"
int receiver = 11; // receiver pin
int speed = 0;
IRrecv irrecv(receiver); 
decode_results results;
void setup() { 
  pinMode(4, OUTPUT); // IN1
  pinMode(5, OUTPUT); // IN2
  pinMode(6, OUTPUT); // EN1
  pinMode(7, OUTPUT); // IN3
  pinMode(8, OUTPUT); // IN4
  pinMode(9, OUTPUT); // EN2
  Serial.begin(9600);
  //Serial.println("IR Receiver Button Decode"); 
  irrecv.enableIRIn(); // Start the receiver
}

void loop() {
 if (irrecv.decode(&results)) {// have we received an IR signal?
 translateIR(); 
 irrecv.resume(); // receive the next value
 }
 analogWrite(6, speed); // CONTROL MOTOR1 SPEED
 analogWrite(9, speed); // CONTROL MOTOR2 SPEED
}
/*-----( Functions)-----*/
void translateIR() {// takes action based on IR code received
// describing Remote IR codes
  switch(results.value) {
    case 0xFF629D: forward(); break; // FORWARD button
    case 0xFF22DD: if (speed > 0)speed--; break; // "LEFT" button
    case 0xFF02FD: Serial.println("-OK-"); break; // 
    case 0xFFC23D: speed++; break; // RIGHT button
    case 0xFFA857: back(); break; // BACK button
    default: 
      Serial.println(" other button ");
  }
 delay(500);
}

void forward(){ // SPIN BOTH MOTORS FORWARD
  digitalWrite(4, HIGH);
  digitalWrite(5, LOW);
  digitalWrite(7, HIGH);
  digitalWrite(8, LOW);
 }
void back(){ // SPIN BOTH MOTORS BACK
  digitalWrite(4, LOW);
  digitalWrite(5, HIGH);
  digitalWrite(7, LOW);
  digitalWrite(8, HIGH);
 }

---

את המדריך המלא ניתן לרכוש כאן

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