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

book-dc-motor

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

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

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

טרנזיסטור

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

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

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

 

book-2n3904

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

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

book-fritzing-dc

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

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

דיודה

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

קבל

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

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

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

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

book-dc-2n3904

 

קוד:

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 יותר מהטרנזיסטור הקודם.

book-tip120-explanation

 

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

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

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

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

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

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

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

h-bridge_diagram

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

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

store-l293d-ic

l293d-pin-diagram

חיבורים:

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

fritzing-l293d

book-l293d

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

מנועי צעד

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

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

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

store-uln2003

store-28BYJ-48-DC-5V-Stepper-motor

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

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 שמפשטת יותר את הקוד ואפשר להשתמש בה וגם בדוגמאות שלה.

book-stepper-motor

 

NEMA

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

מנוע צעד NEMA 17

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

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

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

360/1.8=200

מנועי סרוו

store-towerpro-micro-servo

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

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

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

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

book-servo-motor

 

קוד:

#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 נכללים תחת הפרוטוקול של תקשורת טורית אבל יש ביניהם כמה הבדלים ולכל אחד יתרונות וחסרונות:

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

i2c-bus
I2C bus

 

spi-three-slaves
spi-three-slaves

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

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

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

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

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

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

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

 

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

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

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


 

מסך LCD

store-lcd-1602

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

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

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

book-lcd-headers2

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

book-lcd-headres1

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

book-lcd-headers3

הסבר על הפינים של 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 ומגיעה עם סביבת העבודה של ארדואינו.

 

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

book-fritzing-lcd

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

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

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

lcd.begin(16, 2);

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

lcd.print("");

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

lcd.setCursor();

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

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

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

book-text-lcd

 

קוד:

#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(){}
lcd-i2c-display
lcd-i2c-display

לוח מקשים

store-arduino-key-pad-4x3

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

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

book-arduino-keypad

 

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

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

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

חיבורים:

book-keypad-electric-lock

 

קוד:

#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;
 }

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

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

book-electromagnetic-spectrum

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

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

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

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

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

store-IR-remote

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

store-DC-Stepper-Motor-Drive-Controller

חיבורים:

 

l298-driver-module

 

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

הפונקציות פה הם די פשוטות – אם רוצים לדוגמה לסובב את מנוע 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);
 }

book-motors-ir


תקשורת בלוטוס

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

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

כמו בצורות תקשורת אחרות רבות משתמשים כמו I2C , SPI גם פה יש הגדרה של MASTER ו-SLAVE . מיהו האדון שמנהל את כל המשרתים שעובדים בשבילו 🙂 . האדון יכול לדבר עם כל המשרתים שלו אבל המשרתים לא יכולים לדבר אחד עם השני כמו בצורה של הפרד ומשול. יש גם פרופילים שונים של בלוטוס כמו של העברת אודיו, שליטה בקונסולות משחק או הפרופיל שנשתמש בו שהוא פרופיל תקשורת טורית (SPP). יש כאןהסבר מצוין על הבסיס של תקשורת בלוטוס אם זה מעניין אתכם.

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

מודול בלוטוס הדלקת נורה

מודול בלוטוס על מטריצה

 

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

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

האפליקציה הכי פשוטה שהצלחתי למצוא היא Arduino Bluetooth של circuit magic. מתקינים אותה ואז לוחצים על CONNECT. בוחרים מהרשימה את HC-05 ואז בדרך כלל נדרשת ססמה שבפרוטוקול בלוטוס היא כמעט תמיד 1234, ואז נכנסים אל Led controller.

bluetooth-app-1

bluetooth-app-2

bluetooth-app-3

 

לחיצה על אייקון ON תשלח את הספרה 1 אל המודול שיעביר את זה לארדואינו, ולחיצה על אייקון OFF תשלח את הספרה אפס. עכשיו נכתוב את הקוד בארדואינו שיקבל את המידע:

void setup(){
    Serial.begin(9600);                                  
    pinMode(13, OUTPUT); 
}

void loop() {
   if(Serial.available() > 0) {
      char data = Serial.read();  
      if(data == '1'){            
         digitalWrite(13, HIGH);
      }  
      else if(data == '0') {        
         digitalWrite(13, LOW);
      }
   }
}

 

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

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

bluetooth-app-4

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

void setup(){
    Serial.begin(9600);                                  
    pinMode(11, OUTPUT); 
}

void loop() {
   if(Serial.available() > 0) {
      int data = Serial.parseInt();
      analogWrite(11, data);   
   }
}

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

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

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

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

bluetooth-app-6

 

bluetooth-nokia5110

 

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

if(Serial.available() > 0) {
      String data = Serial.readString();
      // now we can write data into the lcd
}

שינוי הגדרות במודול

המודול HC-05 הוא לא כזה אהבל כמו שזה נראה ממבט ראשון ויש אפשרות לשנות את ההגדרות שלו באמצעות פקודות AT ברגע שנכנסים למצב הגדרות(SET). כדי לעשות את זה מושכים את רגל EN אל 5 וולט בארדואינו או שלוחצים על הכפתור שנמצא על המודול. ישנם 35 פקודות AT שונות איתם אפשר לשנות ססמה, שם שנחשף בפני משתמשים, תפקיד(master/slave), קצב העברת נתונים ועוד הרבה דברים אחרים.

לא הייתי ממליץ למתחילים להתעסק עם זה בכלל אבל אם כבר החלטתם לעשות את זה תשתדלו בתור התחלה לא לשנות קצב נתונים (baud rate) כי זה יכול להפסיק את התקשורת עם הארדואינו. עם האפשרות להשתמש בשני מודולים HC-05 כדי לדבר אחד עם השני (master mode) לא נתעסק פה אבל אולי בפעם אחרת, יש על זה הרבה מידע ברשת אם אתם מחפשים.

 


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

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

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

איך האינטרנט עובד?

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

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

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

צריך להבחין גם בין רשת מקומית(LAN) לרשת גלובלית(WAN) – הארדואינו שנחבר לאינטרנט הוא חלק מרשת מקומית של הבית שלנו והמוח של הרשת הזו הוא הנתב הביתי שלנו. כתובת ה- IP שיקבל הארדואינו תהיה בטווח שנקבע על ידי הנתב בדרך כלל: 192.168.1.100 –  192.168.1.200  כלומר סיומת של בין 100 ל- 200.

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

שליחת נתונים אל האינטרנט

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

 

blog-alarm-ethernet

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