לוחות ארדואינו – מא' עד ת'

הפעלת מנוע
 
המנועים איתם נשתמש במדריך זה הם מנועים הפועלים בעזרת זרם ישר (DC). מנוע סטנדרטי יכול להסתובב לשני כיוונים, בכיוון השעון ונגד כיוון השעון. כיוון הסיבוב של המנוע נקבע על פי הכיוון המתח שנספק לו כלומר: פלוס ומינוס לכיוון אחד ומינוס ופלוס לכיוון אחר.
 
בכדי שנוכל להפעיל מנוע בעזרת לוח הפיתוח נזדקק לפין המסוגל להפיק אות PWM כפי שכבר ראינו בחלקו הראשון של המדריך. לרוב מנועים צורכים זרם רב מעבר ליכולתו של לוח הפיתוח, דבר שיכל לגרום לשריפת הלוח. בכדי להימנע מסיכון זה
וכדי שתהיה לנו אפשרות לשנות את כיוון המנוע ביתר קלות נשתמש ברכיב הנקרא גשר H. הרכיב הספציפי איתו נשתמש
במדריך זה הוא L298N אשר מסוגל להפעיל שני מנועים.
גשר H
 
שמו של גשר H נובע מצורת סכמת המעגל המתאר אותו, כפי שניתן לראות באיור הבא:
באיור ניתן לראות את המנוע באמצע ומסביבו ארבעה מתגים שונים. אופן הפעולה של הגשר הוא פשוט מאוד. ישנם שלושה מצבים כבוי, סיבוב לימין וסיבוב לשמאל, כאשר כל המתגים פתוחים אין החשמל זורם דרך המנוע ולכן הוא נשאר דומם. כאשר זוג מוצלב סגור (עליון שמאלי, תחתון ימני או עליון ימני ותחתון שמאלי) המנוע יסתובב בכיוון המתאים.
 
באיור הבא ניתן לראות כיצד אפשר לחבר את הרכיב שברשותנו ללוח הארדואינו:
באיור אנחנו רואים שעבור כל מנוע יש לנו שני חיבורים, אחד שולט על מהירות הסיבוב ולכן יחובר לפין PWM והשני שולט על כיוון הסיבוב בהתאם למצבו (HIGH או LOW) והוא יחובר לאחד הפינים הדיגיטליים. בנוסף, אנו רואים שיש חיבור מתח חיצוני המאפשר להפעיל את המנוע, לכניסה זו נחבר מקור מתח חיצוני המתאים לדרישות המנוע. רכיב זה מסוגל להתמודד עם מתחים עד לגובה של 46 וולט.
 
כמו כן נשים לב שקיים ג'מפר עם הכיתוב VS=VD. ג'מפר זה קובע שהמתח של המנועים והרכיבים על הלוח המכיל את הגשר יהיה זהה. נקפיד להסיר את הג'מפר הזה. המתח שהלוח הזה יקבל עבור פעולת הרכיבים עליו יהיה 5 וולט מלוח הפיתוח שלנו (הארדואינו).
 
דוגמת קוד בסיסית להפעלת מנוע:
 

#define MotorSpeedPin 5
#define MotorDirectionPin 4
 
void setup() {
  pinMode(MotorSpeedPin, OUTPUT);
  pinMode(MotorDirectionPin, OUTPUT);
  digitalWrite(MotorDirectionPin, LOW);
  analogWrite(MotorSpeedPin, 0);
}
 
int Direction = LOW;
 
void loop() {
     digitalWrite(MotorDirectionPin, Direction);
     for (int i = 0; i <= 255; i = i + 17) {
           analogWrite(MotorSpeedPin, i);
           delay(200);
     }
     for (int i = 255; i >=0; i = i – 17) {
           analogWrite(MotorSpeedPin, i);
           delay(200);
     }
     Direction = (Direction == LOW) ? HIGH : LOW ;

}

 
תחילה הגדרנו את הפין האחראי על מהירות המנוע (פין המאפשר PWM) ולאחר מכן פין דיגיטלי לכיוון הסיבוב. בשלב ה-Setup קבענו ששני הפינים האלו ישמשו כיציאות. את הפין הדיגיטלי הורדנו ל-LOW (כיוון אחד) ואת המהירות הגדרנו כ-0 כדי שלא יפעל.
 
לאחר מכן, הגדרנו משתנה שיכיל את כיוון הסיבוב של המנוע אותו נשנה במהלך התוכנית. בחלק הראשי של התוכנית תחילה קבענו את כיוון התנועה. בלולאה הראשונה ניתן לראות שהמנוע עובר ממצב מנוחה עד למצב של מהירות מלאה עם קפיצות של 17 בערך. בלולאה השנייה המנוע עובר ממצב של מהירות מלאה למצב מנוחה ומיד לאחר מכן אנחנו משנים את משתנה הכיוון שיכיל את הכיוון השני. השורה הזו אומרת: שים במשתנה Direction את HIGH אם Direction שווה ל-LOW. אחרת, שים בו LOW. בסיבוב השני של התוכנית המנוע יתחיל להסתובב לכיוון השני וכן הלאה.
 
במידה ונרצה לשלוט על מאוורר נוסף פשוט נוסיף עוד שני פינים, אחד דיגיטלי ואחד בעל יכולת PWM ונשנה את הקוד בהתאם כך שהוא יתייחס למאוורר הנוסף.
 
שליטה על מאורר
 
במידה ונרצה לשלוט על מאוורר של מחשב, את רוב העבודה כבר ביצענו וכל שנותר הוא שים לב שסביר להניח שאת המאוורר שברשותנו לא נוכל לסובב לשני כיוונים שונים, משום שהוא פועל בכיוון אחד בלבד. הנתון הנוסף שנרצה לקבל מהמאוורר הוא כמה סיבובים לדקה הוא . זאת נוכל לגלות בעזרת החוט הצהוב (לרוב) היוצא ממנו.
 
קריאת RPM ממאוורר אינה ישירה, כלומר החוט לא מספק לנו מתח רציף שלפי רמתו נוכל לדעת כמה סיבובים הוא בכל זמן נתון. כדי לקרוא RPM המאוורר עושה שימוש באפקט הול עליו תוכלו לקרוא בהרחבה בויקיפדיה. העיקרון המרכזי הוא שבמנוע ישנם מספר מגנטים שכל מעבר על אחד מהם יוצר מתח חשמלי בחוט הצהוב אותו ניתן לקרוא. לאחר מספר קריאות בפרק זמן נתון נוכל לחשב בקלות את מספר הסיבובים לדקה עבור המאוורר.
  
חיבור נגד Pull-Up ו-Pull-Down
 
לפעמים במעגל שלנו ישנם מספר רכיבים לוגים שנרצה לשמור עליהם במצב לוגי מסוים (HIGH או LOW). לשם כך נוכל לבצע את החיבורים הבאים:
 
עבור Pull-up:
עבור Pull-down:
נוכל לראות שההבדל בין שני החיבורים האלו הוא שב-pull-up הנגד מחובר להדק החיובי של הסוללה וב-pull-down הוא מחובר להדק השלילי.
 
פסיקות (Interrupts)
 
לפעמים קיימים מצבים בהם נרצה להפריע למהלך רציף של התוכנית מסיבה כלשהי. הסיבה יכולה להיות לחיצה על כפתור, טיימר שקפץ וכו'. עבור פעולות אלו קיים מנגנון הנקרא "פסיקות". בכדי להשתמש בפסיקה יש צורך להגדיר את מקור הפסיקה ואת יעד הפסיקה (הפונקציה אליה תתבצע הפניה בזמן הפסיקה). כאשר תתבצע פסיקה במערכת תתבצע קפיצה ישירה לפונקציה שהוגדרה מראש ובסיומה, התוכנית תמשיך לעבוד מאותה הנקודה בה התרחשה הפסיקה.
   
לדוגמא, נגדיר פסיקה המוגדרת כאשר מתבצעת לחיצה על כפתור, הפסיקה תפעיל פונקציה שמדליקה לד. בתוכנית הראשית, ה-Loop, ישנה לולאה הסופרת מ-1 עד 30 אלף. כאשר המונה הגיע ל-10,000 לחצנו על כפתור. התוכנית תקפוץ מיד לפונקציה שמדליקה את הלד ולאחר מכן תמשיך מאותה נקודה ותקדם את המונה ל-10,001.
   
כעת נתבונן בקוד הבא:
 

#define HallPin 2
#define BIPOLE 2
 
int counter;
 
void RPMCounter() {
      counter++;
}
 
void setup() {
  pinMode(HallPin, INPUT);
  attachInterrupt(0, RPMCounter, RISING);
  Serial.begin(9600);
}
 
void loop() {
     counter = 0;
     sei();
     delay(1000);
     cli();
     int rpm = (counter*60)/ BIPOLE;
     Serial.print(rpm, DEC);
     Serial.print(" RPMn");

}

 
תחילה הגדרנו את הפין אליו מתחבר החוט הצהוב של המאוורר כפין מספר 2. פין מספר 2 הוא גם INT0 (פסיקה מספר 0), לכן כאשר תהיה התייחסות לפין זה בהקשר של פסיקה נשתמש ב-0 ולא ב-2. הקבוע BIPOLE הוא למעשה מספר הקטבים (המגנטים) שיש במאוורר, המשתנה counter יספור את כמות הפסיקות והפונקציה RPMCounter תיקרא כאשר תתבצע פסיקה ותקדם את המונה.
 
בפונקציה ה Setup אנחנו מגדירים שפין מספר 2 ישמש ככניסה ויוצרים הפניית פסיקה חדשה בעזרת הפונקציה attachInterrupt כאשר הערך הראשון הוא פין הפסיקה, השני הוא שם הפונקציה שתרוץ בזמן הפסיקה והשלישי מתי הפסיקה תופעל. כאשר הקבוע RISING מסמן שהפסיקה תעבוד כל פעם שהמצב בפין יעבור מ-LOW ל-HIGH.

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

 
חישוב הסיבובים מתבצע בשיטה הבאה: הכפלת כמות הפסיקות ב-60, כמספר השניות בדקה, חלקי כמות המגנטים שיש במאוורר וזאת משום שכל מעבר על מגנט יוצרת מתח שנקרא, כלומר שבסיבוב מלא אחד אנחנו קוראים שתי פסיקות. לבסוף נשלח בעזרת סריאלית את ערך ה-RPM שהצלחנו לקרוא מהמנוע.
 
קריאת חיישן טמפרטורה אנלוגי
 
כדי להדגים כיצד ניתן לעשות שימוש בכניסות הדיגיטליות אנחנו נשתמש בחיישן הטמפרטורה TMP36. אם נתבונן בדפי הנתונים שלו נוכל לראות שטווח הטמפרטורות של החיישן נע בין 40(-) עד 125 מעלות צלסיוס. כמו כן, עבור המתח שמוציא החיישן בכדי שנוכל לקרוא הוא 10 מילי-וולט עבור כל מעלה. נתון חשוב נוסף הוא שבטמפרטורה של 25 מעלות החיישן מספר 750 מילי-וולט כלומר ערך של 100 מילי-וולט הוא למעשההבסיס שלנו (מינוס 40) וממנו אפשר להתקדם ולבצע חישובים.
את החיבור נבצע בצורה הבאה:
את רגל הסיגנל (Vout) נחבר לכניסה האנלוגית מספר 0 בארדואינו ואת המתח נחבר ליציאת 3.3 וולט של הארדואינו. הסיבה שאנחנו מספקים לחיישן 3 וולט ולא 5, היא כדי לקבל רזולוציה טובה יותר בקריאת הנתונים משום שערך זה קרוב יותר לערך המקסימלי שהחיישן מסוגל לספק. בנוסף, נחבר את יציאת 3.3 וולט לכניסת AREF כדי  שה-ADC ידע לחשב את הערך המקסימלי (1023) יחסית למתח זה ולא יחסית ל-5 וולט כברירת מחדל.
 
קוד לדוגמא:
 

#define aref_voltage 3.3 
 
int tempPin = 0;
int tempReading;
 
void setup(void) {
  Serial.begin(9600);  
  analogReference(EXTERNAL);
}
 
 void loop(void) {
 
  tempReading = analogRead(tempPin); 
 
  float voltage = tempReading * aref_voltage;
  voltage /= 1024.0;
 
  float temperature = (voltage – 0.5) * 100;
  Serial.print(temperature);
  Serial.println("c");
 
  delay(1000);

}

 
בהתחלה הגדרנו קבוע המכיל את מתח הייחוס, במקרה שלנו הוא 3.3 וולט. כמו כן הגדרנו משתנים, הראשון מכיל את מספר הכניסה האנלוגית והשני ישמור את הערך שנקרא בהמשך התוכנית. בשלב ה-Setup נאפשר שימוש בתקשורת סריאלית כדי לראות את הערכים שאנחנו קוראים מהחיישן וכן נגדיר שמתח הייחוס הוא חיצוני (כאמור הפנימי הוא 5 וולט כברירת מחדל).
 
בתוכנית הראשית אנחנו תחילה קריאה אנלוגית מחיישן הטמפרטורה ולאחר מכן ממירים את המספר שקיבלנו למתח שאיתו נוכל לעבוד. לדוגמא אם קראנו ערך של 511 אנחנו מכפילים אותו במתח הייחוס שהוא 3.3 ומחלקים ב-1024, כך קיבלנו ערך של 1.64 וולט.
 
כל שנותר הוא לבצע את החישוב כדי להמיר את המתח למעלות צלסיוס. נשתמש בדפי הנתונים כדי לקבוע מהו הערך עבור 0 מעלות צלסיוס. ידוע לנו ש-750mV הם 25 מעלות וידוע לנו שכל מעלה שוות ערך ל-10mV מכן עולה שנצטרך לחסר 500mV עבור טמפ' של 25 מעלות. לבסוף, נדפיס למסך את הערך שמדדנו ונמתין שניה אחת עד למחזור הבא.

1
2
3
4
5
6

שיתוף

הגב

מיין לפי:   החדש ביותר | הישן ביותר | המדורג ביותר
tal5870
אורח

כתבה מעולה!

חיים
אורח

יפה מאוד
מאמר מקצועי ומעניין , אין ספק

erant04
אורח

PWM
PWM הוא מתח קבוע (שלא משנה מה רמת המתח שלו) והדבר היחיד שמשתנה בו הוא ה-Duty Cycle כאשר:
0% = מתח מינימלי (לרוב אפס).
50% = משך הזמן שהמתח הוא מקסימלי שווה למשך הזמן שהמתח הוא מינימלי (לרוב אפס).
100% = מתח מקסימלי.

dvir01
אורח

נהנתי לקרוא
תודה!

t83
אורח

תודה רבה!

אלכס
אורח

כתבה יפה ועוד אתר בנושא
כל יוזמה לקדם את הנושא מבורכת!
הייתי מוסיף גם את הבלוג הזה לרשימת האתרים המומלצים:
http://bildr.org/

udif
אורח

עוד
קנייה זולה של לוחות:
http://www.seeedstudio.com
http://www.iteadstudio.com

הכי זול כנראה תמצאו באיביי.

זולים משמעותית מ-sparkfun, והמשלוח שגם כך הוא זול, הופך להיות חינם מ-$50.

לוחות ARM:
מעבר ללוחות ARM מבוססי דוט נט, ישנם לוחות ARM שמריצים מערכת נייטיב. חפשו את leaf maple ותואמיהם בשתי החנויות שלמעלה.
ישנם גם לוחות מבוססי PIC32 ב- digilentinc.com שמריצים גם הם גרסה של ארדואינו, חפשו chipkit בגוגל.

אבי מי שרוצה להכנס לעולם הבקרים באופן
ה כ י – ז ו ל , שיחפש את הקיט מבוסס MSP430 של TI הנקרא Llaunchpad' שעולה, כמה (לא) מקרי, $4.30
כן, $4.30 ללוח שכולל בקר וחיבור צריבה/דיבאג ב- USB.
המחיר, דרך אגב כולל משלוח מהיר לארץ,
וכן, TI מפסידה על כל אחד.

הלוחות הראשונים הגיעו רק עם 2K זכרון פלאש ו- 128 בייט RAM, אבל הם מגיעים עכשיו עם 8K פלאש.
אם יש לכם פרוייקט ממש פשוט שנכנס לגודל הזה, זה הפתרון הזול ביותר.
בניגוד לפתרונות למעלה שמשתמשים בסביבת הארדואינו, כאן מדובר על סביבה אחרת לגמרי מבוססת eclipse הנקראת code composer studio.

card
אורח

אפשר למצוא גם ב-buyincoins.com דברים לארדואינו
ובהרבה יותר זול מהאתרים שנתת בכתבה..

(ומשלוח חינם לארץ, כמובן)

תחפש את המילה Arduino באתרים הסיניים,
כמו dealextreme.com
buyincoins.com
וכו'

שיימיס
אורח

יש פה משהו לא ברור
מה זה אומר
'בייצוג הקסהדצימאלי בית אחד מכיל שתי ספרות, כלומר הערך הגבוה ביותר לבית הוא 255 בדצימאלי ו 0xFF בהקסהדצימאלי.'

אבי.ג
אורח

טעות קטנה
"הוא רכיב זיכרון בסיסי המורכב ממספר משתנה של ביטים או בתים. רובנו שמענו את המושג מעבד 32-bit או מעבד 64-bit אבל מה המשמעות של המושג הזה? המשמעות היא שהאוגרים הגדולים ביותר במעבד יכולים להכיל לכל היותר 32 או 64 סיביות או לחילופין 8 או 16 בתים בהתאמה."

צריך להיות רשום "4 או 8 בתים בהתאמה".

wpDiscuz