10 - מנוע DC, המשך

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

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

 

H-bridge הוא סוג של רכיב הידוע גם כרכיב מעגלים משולבים (IC – Integrated Circuits). מעגלים משולבים הם רכיבים המחזיקים מעגלים גדולים באריזה קטנה. הם מפשטים את המעגלים המרוכבים ע”י הצבה שלהם במקום חלק מהמעגל. לדוגמא, ל H-bridge יש כמה טרנזיסטורים מובנים בתוכו (כדי לבנות את המעגל שבתוך ה H-bridge לבד היינו כנראה צריכים לוח מטריצה נוסף).

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

 

חיבור הרכיבים

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

הוסיפו שני מתגים ללוח המטריצה כך שיתיישבו על החוצץ של הלוח. את הרגל הראשונה (השמאלית העליונה) חברו לעמודת ה+ של הצד שלה (בעזרת חוט מגשר), ואת הרגל שמתחתיה חברו לפין הדיגיטלי מס’ 5. בנוסף, חברו נגד 10K אוהם מהרגל הרביעית (הימינית התחתונה) לעמודת המינוס של הצד השני של לוח המטריצה. בצעו זאת שוב עם המתג השני, מקמו אותו מתחת למתג הראשון וחברו אותו לפין מס’ 4. (המתג הראשון המחובר לפין 5 ישלוט על הכיבוי / הדלקה, בעוד המתג השני, המחובר לפין 4 ישלוט על כיוון הסיבוב).

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

מקמו את ה H-bridge באמצע לוח המטריצה (כך שכמו המתגים, יתיישב על החוצץ ויחובר ל-2 צדדי לוח המטריצה, לא לשכוח שהגומה, U, צריכה להיות בראש הגשר). את פין מס’ 1 של הגשר (זוכרים? הפין השמאלי העליון) חברו לפין הדיגיטלי מס’ 9 של הארדואינו, כשהמתח (5V, HIGH) יגיע אליה הוא תפעיל את המנוע, וכשהוא לא יקבל מתח (0V, LOW) הוא יכבה את המנוע.

חברו את פין מס’ 2 של הגשר לפין הדיגיטלי מס’ 3 של הארדואינו, ואת פין מס’ 7 של הגשר לפין הדיגיטלי מס’ 2 של הארדואינו. עם הפינים האלה נתקשר עם המנוע ונגיד לו לאיזה כיוון להסתובב. אם פין מס’ 3 יתן מתח LOW ופין מס’ 2 יתן HIGH המנוע יסתובב לכיוון אחד, ואם הפוך (פין מס’ 3 יתן מתח HIGH ופין מס’ 2 יתן LOW) המנוע יסתובב לכיוון השני (אם 2 הפינים יהיו LOW או HIGH יחדיו, המנוע יפסיק להסתובב).

ה H-bridge מקבל את הכוח שלו דרך פין מס’ 16 אז חברו אותו לעמודת ה+. ואת הפינים 4 ו-5 חברו לאדמה. את המנוע נחבר לפינים מס’ 3 ו-6, כשזה לא משנה איך מכיוון שהם יחליפו בינהם את המתח (פעם הראשון יתן מתח והשני לא ובמידה ונשנה כיוון אז השני יתן והראשון לא). לבסוף, נחבר את פין מס’ 8 של הגשר אל עמודת הפלוס של הסוללה. זה הפין “השואב” את המתח מהסוללה והגשר יעביר את אותו המתח למנוע (הרי המנוע מחובר לגשר, ולא לסוללה).

להלן סכמה ואיור להמחשה:

Wiring Sketch

הקוד

אז לפני שנתחיל לכתוב את התוכנית עצמה, כמו תמיד, נכתוב את המשתנים הקבועים שיהוו תחליף למספרי הפינים, כדי שלא נצטרך להתעסק עם עוד מספרים בלי הגיון מסודר. פינים מס’ 2 ו-3 יהיו פיני השליטה שלנו על הגשר (דרכם נשנה את כיוון הסיבוב של המנוע, אליהם נשלח את הפקודה) לכן נקרא להם controlPin1 ו controlPin2 (בהתאמה). לאחר מכן פין 9 (שמקשור לגשר) יהיה זה שיכבה / יפעיל את המנוע (אליו נשלח את הפקודה) ונקרא לו enablePin. פין 4 יהיה של המתג השני, הוא אחראי על החלפת כיוון הסיבוב (ממנו נקבל את פקודת שינוי הכיוון) ולכן נקרא לו directionSwitchPin. ופין מס’ 5 אחראי על הפעלה / כיבוי של המנוע (ממנו נקבל את פקודת ההפעלה / כיבוי) ולכן נקרא לו onOffSwitchStateSwitchPin, ולבסוף הפין האנלוגי A0 (שמחובר לפוטנציומטר), ממנו נקבל את ערכי מהירות הסיבוב ונקרא לו potPin.

כעת נגדיר את משתני העזר לתוכנית, המשתנים הראשונים יהיו משתני עזר שיחזיקו לנו את הערכים מהקריאות של המתגים והפונטציומטר. הראשון יחזיק לנו את הערך מהמתג הראשון, נקרא לו onOffSwitchState, השני יחזיק לנו את הערך הקודם של המתג הראשון (כדי שנוכל לבדוק האם הוא ישתנה, ז”א האם לחצו על המתג) אז נקרא לו previousOnOffSwitchState, השלישי יחזיק לנו את הערך מהמתג השני, של השינוי כיוון, נקרא לו directionSwitchState, ושוב כדי לראות האם הוא לחצו עליו או לא נצטרך להשוות אותו עם הערך הקודם שקראנו מהמתג הזה, לכן ניצור עוד משתנה שישמור את הערך הקודם, ונקרא לו preciousDirectionSwitchState, לאחר מכן ניצור משתנה בשם motorSpeed שישמור לנו את מהירות הסיבוב, ומשתנה בשם motorEnabled שיזכור האם המנוע פועל כרגע או לא, וכמובן משתנה בשם motorDIrection שיעקוב אחרי כיוון הסיבוב של המנוע (1 או 0, ימינה או שמאלה. זהו הערך היחידי שנאתחל אותו מהתחלה להיות 1 ולא 0).

 

בפוקנציית ה ()setup:

נגדיר את הפינים להיות קלט / פלט:

  • directionSwitchPin יהיה במצב קלט, הוא שומר את ערכי המתג השני, ועל פי ערכים אלו נידע האם יש לשנות את כיוון סיבוב המנוע.
  • onOffSwitchStateSwitchPin גם יהיה במצב קלט, ממנו נקלוט את ערכי המתג הראשון (וכך נידע האם לכבות / להדליק את המנוע).
  • controlPin1 ו controlPin2 יהיו פלט, מכיוון שאליהם אנו שולחים את המתח שקובע את כיוון הסיבוב של המנוע.
  • enablePin יהיה פלט, דרכו נכבה ונדליק את פעולת המנוע.

לבסוף, כדי לוודא שהמנוע מתחיל במצב כבוי, נכתוב (בעזרת הפונ’ ()digitalWrite) לפין מס’ 9 (enablePin) להיות כבוי (ז”א מתח LOW).

 

בפונקציית ה ()loop:

הדבר הראשון שאנחנו צריכים לעשות בפונ’ ה loop הוא לקרוא האם ביקשו להדליק את המנוע, ז”א לחצו על המתג הראשון. לכן, נקרא את הערך מהמתג (שמספרו שמור במשתנה onOffSwitchStateSwitchPin) בעזרת הפונ’ ()digitalRead ונשמור את הערך שנקבל במשתנה בשם onOffSwitchState. לאחר מכן נחכה מאית שניה ונקרא גם את הערך מ directionSwitchPin כדי לדעת אם ביקשו לשנות את הכיוון של המנוע. ולבסוף נקרא את הערך מהפין האנלוגי potPin (בעזרת הפונ’ ()analogRead) ונחלק את הערך ב-4 (על מנת להתאימו לערכים של המנוע), ונשמור את הערך במשתנה בשם motorSpeed. אלו הם הדברים הראשונים שיש לעשות, לקרוא את הערכים משתי המתגים ומהפוטנציומטר, על מנת לדעת אם הם השתנו, ז”א האם ביקשו לבצע פעולה כלשהי. רק לאחר מכן אנו יכולים לבדוק האם הם אכן השתנו ולפעול בהתאם.

 

נבדוק האם ביקשו להדליק / לכבות את המנוע, נבצע זאת ע”י פקודת if מקוננת (ז”א 2 פקודות if, אחת בתוך השניה), קודם כל נבדוק האם הערך שקראנו עכשיו (השמור במשתנה onOffSwitchState) שונה מהערך שקראנו בפעם הקודמת (השמור במשתנה previousDirectionSwitchState) (בפעם הראשונה לא שמור שם כלום חוץ מהערך ההתחלתי אותו הצבנו כשיצרנו את המשתנה, והוא 0, ז”א LOW) (את הבדיקה האם הם שווים אנו מבצעים ע”י פעמיים הסימן שווה, ==, את הבדיקה האם שתי ערכים שונים אחד מהשני מבצעים ע”י סימן קריאה ושווה, =!). במידה והאם שונים, ניכנס לתוך ה if, ואז נשאל שוב (עם עוד if) האם הערך שקראנו (onOffSwitchState) שווה ל HIGH, במידה וכן אנו צריכים להפוך את הערך שבמשתנה motorEnable (ז”א אם הוא היה 0 כעת הוא יהיה 1, ולהפך. נבצע זאת עם סימן הקריאה לפני המשתנה, המסמן שלילה. והשווה הוא כדי להציב אותו בתוך עצמו. אח”כ אנו נבדוק למה המשתנה שווה כדי לדעת איזה מתח לשלוח לגשר).

נבצע אותו הדבר עם הכיוון, נכתוב if מקונן (שתיים, אחד בתוך השני) כשב if הראשון נבדוק האם הכיוון השתנה (ז”א האם הכיוון שקראנו כעת, directionSwitchState, שונה מהכיוון שקראנו בפעם האחרונה, previousDirectionSwitchState). במידה והוא השתנה, נבדוק האם הוא שווה ל-1 (HIGH), ובמידה ושווה נחליף את הערך במשתנה השומר לנו את הכיוון של המנוע (motorDirection).

אחרי הבדיקות, נתחיל לשלוח את הערכים המתאימים לגשר (שבתורו יפעיל / יכבה את המנוע). ע”י משפט if / else נבדוק את כיוון המנוע הנוכחי (ז”א האם הערך motorDirection שווה ל-1, אם לא אנחנו הוא שווה ל-0, ואז ניכנס ל else). אם הוא שווה ל-1, נשלח (בעזרת הפונ’ ()digitalWrite), ערך HIGH ל controlPin1 וערך LOW ל controlPin2, אחרת ההפך (LOW ל controlPin1 וערך HIGH ל controlPin2). (האמת שזה לא משנה, אתם גם יכולים להחליף בינהם, מה שזה בעצם אומר שהגשר יחליף את ערכי המתח למנוע, במקום את החוט האדום ב+ והשחור ב-, ואז להחליף, אנחנו פשוט משחקים עם המתח המוזרם לכל חוט).

וכמובן שאנו צריכים גם לבדוק האם צריך לכבות את המנוע או לא, שוב ניעזר במשפט if / else, אם motorEnable שווה ל-1, שהרי המנוע צריך לפעול, לכן נשלח (בעזרת הפונ’ ()analogWrite) לפין האנלוגי 9 (שערכו שמור במשתנה enablePin) את הערך שבו הוא צריך להסתובב (ששמור במשתנה motorSpeed) (פין מס’ 9 מחובר לגשר והוא זה שמפעיל / מכבה אותו על פי הזרם שהוא מקבל). במידה והערך הוא 0 ז”א LOW, שהרי המנוע צריך להיות מכובה, לכן נשלח לפין מס’ 9 את המהירות שבו הוא צריך להסתובב שהיא 0.

 

לבסוף, לפני היציאה מה loop, כל שנשאר הוא לשמור את המשתנים הנוכחיים כמשתנים הקודמים (על מנת שבלולאה הבאה של הפונ’ loop, שכזכור פועלת בלולאה אינסופית כל עוד הארדואינו מקבל חשמל, נקרא את הערכים החדשים ונשווה אותם לאלה מהפעם הזאת). נציב את ערך הכיוון (שנמצא במשתנה directionSwitchState למשתנה previousDirectionSwitchState) ואת הערך של המתג ההפעלה / כיבוי (שנמצא במשתנה onOffSwitchState למשתנה previousOnOffSwitchState).

 כך יראה הקוד הסופי:

const int controlPin1 = 2;
const int controlPin2 = 3;
const int  enablePin = 9;
const int directionSwitchPin = 4;
const int  onOffSwitchStateSwitchPin = 5;
const int  potPin = A0;
int onOffSwitchState = 0;
int preciousOnOffSwitchState = 0;
int directionSwitchState = 0;
int previousDirectionSwitchState = 0;
int motorEnable = 0;
int motorSpeed = 0;
int motorDirection = 1;

void setup(){
    pinMode(directionSwitchPin, INPUT);
    pinMode(onOffSwitchStateSwitchPin, INPUT);
    pinMode(controlPin1, OUTPUT);
    pinMode(controlPin2, OUTPUT);
    pinMode(enablePin, OUTPUT);
    digitalWrite(enablePin, LOW);
}

void loop(){
    onOffSwitchState = digitalRead(onOffSwitchStateSwitchPin);
    dealy(1);
    directionSwitchState = digitalRead(directionSwitchPin);
    motorSpeed = analogRead(potPin)/4;
    if (onOffSwitchState !=previousOnOffSwitchState){
        if (onOffSwitchState == HIGH){
            motorEnable = !motorEnable;
        }
    }
    if (directionSwitchState != previousDirectionSwitchState){
        if(directionSwitchState == HIGH){
            motorDirection = !motorDirection;
        }
    }
    if (motorDirection == 1){
        digitlWrite(controlPin1, HIGH);
        digitalWrite(contaolPin2, LOW);
    }else{
        digitalWrite(controlPin1, LOW);
        digitalWrite(controlPin2, HIGH);
    }
    if (motorEnable == 1){
        analogWrite(enablePin, motorSpeed);
    }else{
        analogWrite(enablePin, 0);
    }
    previousDirectionSwitchState = directionSwitchState;
    previousOnOffSwitchState = onOffSwitchState;
}

 

לסיכום

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

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