טכנולוגיהמדריכים

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

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

11111110
11010101
————
11010100

 
פעולה זו שימושית במיוחד כאשר נרצה לבדוק ביט מסויים במספר. לדוגמא, אם נתון לנו מספר כלשהו ואנחנו רוצים לדעת האם הביט החמישי מימין הוא 0 או 1, מה נעשה? פשוט, נבצע את הפעולה & עם המספר הבינארי 00010000 ונבדוק האם התשובה שנקבל שווה ל-0 או לא. אם התשובה היא 0 אזי שבדיוק במקום החמישי במספר אותו אנחנו רוצים לבדוק קיים 0, ואם התוצאה הי אינה 0 אז יהיה לנו 1 בדיוק באותו מקום. שיטה זה נפוצה מאוד ונקראת שימוש במסכה (Mask) כאשר המסכה הוא המספר הבינארי "המיוחד" איתו אנחנו נבצע AND (בדוגמא שלנו המסכה היא: 00010000).
 
פעולת OR (בתכנות נבצע ע"י הסימן "|" ) – שיטה דומה לחיבור אך הערך המקסימאלי מהחיבור יהיה 1. כל ביט שנבצע פעולת OR עם 1 תמיד יהיה 1.
 

11111110
01010100
———–
11111110

 
פעולה זו שימושית כאשר נרצה לבצע שינוי ל-1 עבור ביט מסויים. בדומה לדוגמא הקודמת, אם נתון לנו מספר בינארי כלשהו ונרצה לשנות את הביט במקום החמישי מימין ל-1 נבצע את הפעולה OR עם המספר הבינארי הבא: 000100000.
 
פעולת XOR (בתכנות נבצע ע"י הסימן "^" ) – ניתן לראות בטבלה למעלה שכאשר נבצע את הפעולה עבור שני ביטים זהים נקבל תמיד 0 ועבור שני ביטים שונים נקבל תמיד 1. ניתן להשתמש בפעולה זו במגוון דרכים, אחת מהן נראה בהמשך.
 
פעולת NOT (בתכנות נבצע ע"י הסימן "~" ) – זו פעולת שלילה שמשנה את סימן הביט. אם הביט היה 0 הוא יהפוך ל-1 ולהיפך. ניקח את המספר הבינארי הבא:
 

A = 10101010
A = ~A

 
כעת ערכו של A יהיה 01010101 כלומר כל הביטים התהפכו.
 
פעולות Shift Left, הזזה שמאלה (בתכנות נבצע ע"י הסימן ">>" ) – פעולה המזיזה את כל הביטים במספר הבינארי צעד אחד שמאלה. פעולה זו דומה לפעולת הכפלה ב-2. לדוגמא, ניקח את המספר 1, בבינארי הוא 00000001. אם נבצע עליו את הפעולה >> נקבל 00000010 כלומר את מספר 2. נבצע שוב פעולת >> ונקבל 00000100 כלומר את המספר 4. וכן הלאה. אם יש לנו את המספר 10 הנראה כך: 00001010 נבצע הזזה שמאלה ונקבל: 00010100 שערכו שווה ל-20.
 
פעולות Shift Right, הזזה ימינה (בתכנות נבצע ע"י הסימן "<<" ) – פעולה המזיזה את כל הביטים במספר הבינארי צעד אחד ימינה. פעולה זו דומה לפעולת חילוק 2. ניתן להבין לפי הדוגמא הקודמת את אופן הפעולה של פעולה זו. נשים דגש על מקרה בודד. אומנם אמרנו שפעולה זו מדמה חילוק ב-2 אך במקרה בו יש לנו את המספר 1 המיוצג כ: 00000001 ונבצע הזזה ימינה, לא נקבל חצי מכיוון שלא למדנו כיצד ניתן לייצג מספרים לא שלמים בשיטה זו. במקום זאת, נקבל את המספר 0.
 
שימוש ברכיב Shift Register– לוח הפיתוח מכיל מספר מוגבל של פינים, לא פעם נרצה לשלוט במספר רב של לדים העולה על כמות הפינים האפשריים בלוח. כדי לבצע זאת נוכל להשתמש ברכיב Shift Register. פעולתו של רכיב זה היא די פשוטה, הוא מקבל בית אחד (מספר בינארי מ-0 עד 255) ומפרק אותו לביטים. הוא מכיל 8 פורטים המשמשים כיציאות דיגיטליות כאשר כל ביט במספר הבינארי משויך לפורט המתאים לו. לדוגמא: אם נשלח לרכיב את המספר הבא, 10101010, פורט 0 יהיה ברמה לוגית 0, פורט 1 יהיה ברמה לוגית 1, פורט 2 יהיה ברמה לוגית 0 וכו'. כך נוכל לשלוט בקלות על הלדים לפי הבית שנשלח לרכיב.
 
נוסף על כך, הרכיב מאפשר לנו לשרשר אליו עוד רכיבים זהים כך שנוכל לשלוט תאורטית על מספר לא מוגבל של יציאות דיגיטליות. אם נשרשר שלושה רכיבים נצטרך לשלוח שלושה בתים כאשר הבית הראשון יהיה עבור השלישי בשרשרת, הבית השני יהיה עבור השני והבית השלישי יהיה עבור הראשון בשרשרת.
 
נתבונן בטבלת רגליים של הרכיב:
  • פינים Q0 – Q7 ישמשו כיציאות אותן נחבר ללדים.
  • פין Q7' משמש לשרשור רכיבים נוספים והוא למעשה מעביר את המידע הלאה לרכיב הבא.
  • Vcc כניסת מתח ו GND אדמה.
  • את הפין DS נחבר ללוח כדי להעביר מידע לרכיב.
  • SH_CP חיבור השעון לרכיב לשימוש בחיבור סינכרוני.
  • ST_CP יציג את המידע שהגיע לרכיב כאשר נעביר אותו לרמה לוגית 1.
  • MR משמש לאתחול הרכיב כאשר הוא במצב LOW (הקו העליון מעל השם מסמן פעולה במצב LOW) לכן נחבר אותו
  • קבוע ל HIGH, כלומר למתח החיובי.
  • OE מאפשר יציאה כאשר הוא במצב LOW ולכן תמיד נחבר אותו לאדמה.
 
את החיבור נבצע לפי האיור הבא:
ניתן לראות שישנו קבל של 1 מיקרו-פארד בין האדמה לפין 12 של הרכיב, אם ברשותכם קבל מסוג זה אין חובה לחברו. הוא נועד כדי למנוע רעשים שעלולים להוביל להבהובים לא רצוניים של הלדים.
 
נתבונן בקוד הבא:
 

#define latchPin 8
#define dataPin 11
#define clockPin 12
 
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}
 
void loop() {
    for (int i = 0; i <= 0xFF; i++) {
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, i); 
        digitalWrite(latchPin, HIGH);
        delay(200);
    }

}

 
תחילה הגדרנו את שלושת הפינים הדרושים על מנת לתקשר עם הרכיב. בחלק ה-Setup הגדרנו ששלושת הפינים ישמשו כיציאות. החלק הראשי, Loop, מכיל לולאה שסופרת מ-0 עד 255 כלומר ערכו המקסימאלי של בית אחד. בתוך הלולאה תחילה נוריד את פין ה-latch (ST_CP) למצב LOW  בכדי לקלוט את הנתונים.
 
פונקציה חדשה בשם shiftOut מקבלת כפרמטרים את הפין דרכו המידע יוצא ועובר לרכיב, פין השעון, אופן העברת הנתונים שמיד נרחיב עליו ולבסוף המידע אותו אנחנו רוצים לשלוח כאשר ערכו יהיה בית אחד בלבד. לאחר מכן נעלה את פין ה-latch ל-HIGH כדי שהמידע יוצג על גבי הלדים. בסוף כל לולאה, נגדיר השהייה קצרה שתאפשר לנו לראות את הלדים מאירים. התוכנית המופיעה בקוד למעשה מציגה לנו מספר בצורתו הבינארית על גבי הלדים.
 
הפרמטר השלישי מתייחס לצורת הקריאה של המספר הבינארי. בכל מספר בינארי יש שני ביטים בעלי שם, Most Significant Bit (MSB) ו-Least Significant Bit (LSB) ובעברית: ביט בעל חשיבות גבוהה וביט בעל חשיבות נמוכה בהתאמה.
עבור כל אחת מאפשרויות האלו יש קבוע שהוגדר בספריות המערכת הם MSBFIRST ו-LSBFIRST. נציג עוד תוכנית אחת המדליקה כל פעם את הלד הבא בתור הלוך ושוב:
 

#define latchPin 8
#define dataPin 11
#define clockPin 12
 
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}
 
int unsigned i = 1;
bool flag = true;
void loop() {
     digitalWrite(latchPin, LOW);
     shiftOut(dataPin, clockPin, MSBFIRST, i); 
     digitalWrite(latchPin, HIGH);
     delay(200);
 
     if (flag) {
         i = i << 1;
     }else{
         i = i >> 1;
     }
     if (i == 0x01) flag = true;
     if (i == 0x80) flag = false;

}

 
כדי שהלד הראשון יאיר נשלח ל-Shift register את המספר 1 (00000001). בנוסף נאתחל משתנה דגל שיאמר לנו לאיזה כיוון צריך להתקדם. אמת כאשר צריך לעלות את הערך ושקר בכיוון השני כלומר להקטין את הערך. את הדגל נשנה רק במצבי הקצה שהם 1 או 128 (10000000).
 
כעת נשנה את הקוד כך שהוא יתאים לשליטה בעזרת תוכנה חיצונית שנכתוב:
 

#define latchPin 8
#define dataPin 11
#define clockPin 12
 
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  Serial.begin(9600);
}
 
Byte value = 0;
 
void loop() {
     if (Serial. available () > 0) {
           value = Serial.read();
           digitalWrite(latchPin, LOW);
           shiftOut(dataPin, clockPin, MSBFIRST, value); 
           digitalWrite(latchPin, HIGH);
           delay(200);
     }

}

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