המדריך לפיתוח עם אינטל גלילאו 2: צלילה אל תוך הקוד

להפוך רעיון למציאות: מדריך לכתיבת תוכניות ב-Javascript עבור לוח הגלילאו של אינטל, בסביבת Intel XDK

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

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

 

התקנה

כדי להתקין את Galileo יש להצטייד בכרטיס microSD בעל נפח של לפחות 4GB.
מערכת ההפעלה שנפרוש על הכרטיס הינה לינוקס וניתן להוריד אותה מאתר אינטל בקישור הבא.
הקובץ שוקל כ 210MB ואותו יש לפרוש ע"ג הכרטיס עם תוכנה מיועדת לכן. אנו נשתמש בתוכנה win32diskimager שאותה ניתן להוריד מכאן.

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

מכיוון שללוח איך יציאת וידיאו כלשהי, הלוח מציג מידע בעזרת יציאת ה-serial הנמצאת ליד כניסת הרשת. כדי לראות את המידע הזה יש להשתמש בכבל הסריאלי שמצורף עם הערכה ע"י חיבורו ללוח כמתואר בתמונה:

לאחר חיבור הכבל למחשב מערכת ההפעלה תזהה התקן חדש מסוג USB Serial Port ותעניק לו שם ייחודי מהצורה COMxx, כדי להתחבר לחיבור הסריאלי יש למצוא את השם החדש, במקרה שלנו הוא COM3. לחיבור זה ניתן להתחבר בעזרת תוכנות טרמינל שונות שאחת מהן היא PuTTY
שימו לב: יש להתחבר במהירות של 115200bps

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

הכנת הסנסורים לפרויקט

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

ניתן להוריד את קובץ ה-STL להדפסה כאן.

הפרויקט הראשון

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

כדי להתחיל פרויקט חדש נבחר ב-Templates מהתפריט בצד שמאל. בצד ימין נראה מספר תבניות מוכנות שיכולות לשמש כבסיס לתוכנית אותה אנו רוצים לכתוב. למרות שאחת התבניות היא כבר התוכנית LED Blink, אנחנו נבחר ב-Digital Write היות ונכתוב אותה בצורה קצת שונה.

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

ברשימה אנחנו רואים את שם הלוח (galileo) ואת כתובת ה-IP אותה הוא קיבל מהנתב + מספר הפורט איתו התוכנה מתקשרת.

לאחר בחירת הלוח מהרשימה יופיע חלון ההתחברות המציג את פרטי החיבור מול הלוח ובנוסף שם משתמש וסיסמה. במידה ולא הוגדרה סיסמה ללוח (כברירת מחדל הסיסמה ריקה), יש להשאיר את שדה הסיסמה ריק ובשם המשתמש להשאיר את המשתמש root. לחיצה על Connect תבצע חיבור מול הלוח במידה והכל תקין.
ייתכן ולאחר החיבור יופיע חלון המבקש לבצע Sync ללוח כדי לסנכרן את שעון הלוח מול שעון התוכנה, אין חשש ללחוץ על כפתור Sync.

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

var mraa = require('mraa'); //require mraa 
console.log('MRAA Version: ' + mraa.getVersion()); //write the mraa version to the console
var myDigitalPin5 = new mraa.Gpio(5); //setup digital read on Digital pin #5 (D5)
myDigitalPin5.dir(mraa.DIR_OUT); //set the gpio direction to output
myDigitalPin5.write(1); //set the digital pin to high (1)

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

תחילה יש ללחוץ על הכפתור השני install/build, בפעם הראשונה שאנחנו מריצים את התוכנית יש להתקין אותה על הלוח ולקמפל את כל הרכיבים בהם אנו עושים שימוש בתוכנית, במקרה שלנו הספרייה mraa.
את כל התהליך נוכל לראות בחלון ה-console השחור. במידה והכל תקין תופיע הודעה כפי שמופיע בתמונה הבאה.

כעת אם נריץ את התוכנית ע"י לחיצה על כפתור Run מסרגל הכלים נראה את הפלט הבא:

Intel XDK - Message Received: run
=> Stopping App <=
MRAA Version: v0.6.0

התוכנית החלה לרוץ, פלטה את מספר הגרסה וסיימה את עבודתה.
נמשיך לשלוש השורות הבאות בתוכנית.
אנו יוצרים אובייקט חדש בשם myDigitalPin5 המייצג את פין מספר 5 על הלוח ע"י קריאה לפונקציה Gpio שהיא חלק מהאובייקט mraa.
לאחר מכן מגדירים את כיוון הפין האם הוא יציאה (Output) או כניסה (Input). היות ובתוכנית שלנו LED מופעל מפלט של הלוח ולא מזין לו מידע הפין מוגדר כ-Output.
בשורה האחרונה מתבצעת הכתיבה לפין עם הערך 1 כאשר 1 מייצג רמה לוגית High (יש מתח בפין) ו 0 מייצג רמה לוגית Low (אין מתח בפין(.

כעת נחבר ללוח פיזית את הלד שסופק בערכה ליציאה D5 בלוח ההרחבה.

עכשיו יש לבצע שמירה של השינויים (Ctrl + S) ולאחר מכן נלחץ על הכפתור הראשון בסרגל הכלים Upload. כפתור זה ישלח את הקובץ המעודכן ללוח. לאחר מכן נלחץ על כפתור Run ואם הכל חובר כשורה נראה את הלד דולק באופן קבוע.
*שימוש לב שלא ביצענו עכשיו קימפול מחדש וזאת משום שלא הוספנו ספריות נוספות לפרויקט אותם יש לקמפל מחדש עבור התוכנית.

אם שמתם לב, התוכנית רצה פעם אחת, הדליקה את הלד ונסגרה. זאת משום שבקוד שלנו אין דבר המונע מהתוכנית לסיים את חייה. הלד נשאר דולק לאחר שהתוכנית יצאה משום שאף אחד אחר לא דאג לשנות את היציאה של פין מספר 5 מרמה לוגית 1 ל-0.
מי מכם שעבד בעבר עם Arduino יודע שאת התוכנית עצמה אנחנו רושמים בתוך פונקציה הנקראת loop. הפונקציה הזו מאחורי הקלעים נקראת שוב ושוב ללא הפסקה, זה בדיוק מה שנעשה בתוכנית שלנו.

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

גרסה ראשונה:

var mraa = require('mraa');
console.log("Application Version 1");

var myDigitalPin5 = new mraa.Gpio(5);
var LEDState = 1;

function setup() {
    myDigitalPin5.dir(mraa.DIR_OUT);
}

function loop() {
    myDigitalPin5.write(LEDState);
    LEDState = (LEDState == 1) ? 0 : 1;
}

setup();

setInterval(loop, 1000);

סידרנו את הקוד כך שיראה קצת יותר דומה למבנה סטנדרטי של תוכנית Arduino.
*טיפ: הוספנו בתחילת הקוד את השורה console.log עם פלט אותו נרצה לראות כאשר התוכנית מתחילה לרוץ. לא פעם שוכחים לבצע שמירה של התוכנית וכאשר אנחנו מעלים את התוכנית היא לא מבצעת את מה שצפינו שיקרה. מומלץ לשנות את ההודעה כך שבכל הרצה נראה הודעה שונה וכך נדע שהתוכנית שרצה היא באמת התוכנית אותה התכוונו להריץ.

בתוכנית הנ"ל ניתן לראות שתי פונקציות חדשות אותן הוספנו לקוד והן setup ו loop כאשר לפונקציה setup אנחנו קוראים פעם אחת והיא תבצע איתחולים או פעולות אותן נרצה לבצע רק פעם אחת בתוכנית שלנו.
לפונקציה loop אנחנו קוראים לאחר מכן ע"י שימוש בטיימר מסוג setInterval עם זמן מחזור של 1000 מילישניות.
הפונקציה loop כותבת לפין את הערך הנמצא במשתנה LEDState. לאחר מכן אנחנו משנים את ערכו של LEDState בהתאם לתוכן שבו. אם הוא מכיל 1 נשנה אותו ל 0 ולהיפך.
כעת נשמור, נבצע upload ונלחץ על run.
הלד צריך הלתחיל להבהב בהפרשי זמן של שניה בין כל מצב.
נשים לב כי כפתור ה run נשאר במצב ריצה, זאת משום שעכשיו התוכנית שלנו לא יצאה, היא ממשיכה לרוץ כל הזמן היות ואין מי שיעצור את הטיימר.
אם נרצה להפסיק את התוכנית באופן יזום נלחץ על כפתור ה run בשנית מה שיבצע עצירה של התוכנית.

גרסה שנייה:

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

var mraa = require('mraa');
console.log("Application Version 2");

function delay(ms) {
    var now = new Date().getTime();
    while(new Date().getTime() < now + ms); 
}

var myDigitalPin5 = new mraa.Gpio(5);

function setup() {
    myDigitalPin5.dir(mraa.DIR_OUT);
}

function loop() {
    myDigitalPin5.write(1);
    delay(1000);
    myDigitalPin5.write(0);
    delay(1000);    
}

setup();

while (1) {
    loop();
}

נתבונן בתוכנית ונראה מספר הבדלים.
ראשית הפונקציה delay. כל מה שהיא עושה הוא לדגם את השעה בכניסה אליה (הפלט של getTime הוא במילישניות) ולאחר מכן בתוך לולאת while נבצע דגימה נוספת של הזמן ונשאר האם הזמן הנוכחי קטן מזמן הדגימה הראשוני + מספר המילישניות שנרצה להמתין.
כל עוד התנאי מתקיים הלולאה תמשיך לרוץ ולמעשה משהה את שאר התוכנית. כאשר הלולאה מפסיקה לרוץ, הזמן הנוכחי גדול מזמן הדגימה + כמות המילישניות להמתנה, התוכנית תמשיך לרוץ ותבצע את שאר הפקודות בהמשך.
את הפונקציה loop שינינו כך שתשתמש בפונקציית ה-delay ואנחנו קוראים לה כל הזמן ע"י שימוש בלולאה אינסופית while(1).

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

כדי לשנות את עוצמת האור של הלד יש צורך ביציאה בעלת יכולת PWM (Pulse Width Modulation) בשונה פין דיגיטלי רגיל המאפשר רק מצב של יש מתח או אין מתח, PWM מאפשר לדמות גם רמות שונות של מתח בין שני המצבים ע"י שינוי ב-Duty Cycle שהמשמעות שלו היא כמה אחוז במחזור האות יהיה במצב High וכמה זמן הוא יהיה במצב Low.
אם נקבע Duty Cycle של 50% נקבל שעוצמת האור של הלד תהיה חצי ממה שהיא יכולה להיות אילו הפין היה דיגיטלי במצב High.

נתבונן בתוכנית הבאה:

var mraa = require('mraa');
console.log("PWM");

function delay(ms) {
    var now = new Date().getTime();
    while(new Date().getTime() < now + ms); 
}

var analogPin0 = new mraa.Aio(0);
var LED = new mraa.Pwm(3);

function setup() {
    LED.enable(true);
}

function loop() {
    var analogValue = analogPin0.read();
    var value = analogValue / 1023.0;
    LED.write(value);
    console.log(value);
    delay(10);
}

setup();

while (1) {
    loop();
}

הגדרנו את פין A0 ע"י שימוש באובייקט mraa.Aio וכן הגדרנו את הלד שלנו כ PWM בעזרת mraa.Pwm(3).
בפונקציית setup קראנו לפונציה enable המאפשרת את השימוש בפין הזה במצב pwm.
בפונקציה loop תחילה אנחנו קוראים את הערך אותו מספק הפוטנציומטר מפין A0.
בשונה מ-Arduino, הערכים שיש לכתוב ליציאת pwm הם בין 0 ל 1 ולא בין 0 ל 255, מסיבה זו אנחנו מחלקים את הערך שהתקבל בערך המקסימלי אותו ניתן לקרוא מהכניסה.
את הערך שהתקבל אנחנו כותבים חזרה ללד וכן פולטים אותו למסך לשם הנוחות.
בין כל הרצה של הפונקציה ניתן דיליי קל של 10 מילישניות.
כעת הריצו את התוכנית ושחקו עם הפוטנציומטר, עוצמת הלד צריכה להשתנות בהתאם למשחק.

ניקח את התוכנית שלב אחד קדימה ונכתוב את עוצמת התאורה ע"ג צג ה-LCD המסופק עם הערכה.
את הצג נחבר לאחד מחיבור ה-I2C הנמצאים על לוח ההרחבה.
חיבור ה-I2C מייצג את פרוטוקול I²C  אותו פיתחה פיליפס. הוא מאפשר לחבר מספר רב של התקנים (עד 127) על באס משותף כאשר כל התקן בעל כתובת ייחודית משלו. כך ניתן לחבר מספר גדול של התקנים בעזרת שני פינים בלבד, אחד משמש לשעון משותף והשני מעביר את המידע להתקן הרצוי.

נתבונן בתוכנית הבאה:

var mraa = require('mraa');
var LCD  = require ('jsupm_i2clcd');
console.log("LCD");

function delay(ms) {
    var now = new Date().getTime();
    while(new Date().getTime() < now + ms); 
}

var myLCD = new LCD.Jhd1313m1(0);
var analogPin0 = new mraa.Aio(0);
var LED = new mraa.Pwm(3);
var lcdMessage = "";

function setup() {
    LED.enable(true);
    myLCD.setColor(255, 128, 0);
}

function loop() {
    var analogValue = analogPin0.read();
    var value = analogValue / 1023.0;
    LED.write(value);
    var lastLcdMessage = lcdMessage;
    lcdMessage = "Brightness: " + (value.toFixed(2) * 100) + "%";
    if (lcdMessage != lastLcdMessage)
    {
        myLCD.clear();
    }
    myLCD.setCursor(0,0);
    myLCD.write(lcdMessage);
    delay(100);
}

setup();

while (1) {
    loop();
}

בשורה השניה של התוכנית נראה כי אנחנו משתמשים בספרייה חדשה ושמה jsupm_i2clcd.
ספרייה זו תנהל לנו מאחורי הקלעים את כל התקשורת מול צג ה-LCD ותפשט אותה למספר פונקציות פשוטות וקלות לשימוש.
ספרייה זו היא חלק קטן מתוך מאגר UPM המנהל ממשק מול סנסורים ורכיבים חיצוניים. בניגוד ל mraa שמתעסקת בלוח עצמו UPM מגיע רמה מעל ומאפשר התנהלות פשוטה מול רכיבים אחרים.
ניתן לראות את קוד המאגר וגוון רחב של דוגמאות בדף ה github של הפרויקט:
https://github.com/intel-iot-devkit/upm

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

בפונקציית setup הוספנו קריאה ל setColor של הצג. פונקציה זו משנה את התאורה האחורית של הצג בהתאם לערכי RGB המסופקים לה. כל ערך יכל להיות בין 0 ל 255. לדוגמא 0, 0, 255 יניב תאורה בצבע כחול בלבד היות וערכי R, G הם 0 ו B בעוצמה הגבוהה ביותר שלו, 255.
בפונקציית loop נוסיף משתנה lcdMessage שיכיל את הטקסט אותו נרצה להציג ע"ג הצג.
קריאה ל-myLCD.clear תמחק כל דבר המוצג ע"ג הצג. מכיוון שפונקציה זו יחסית איטית, אם נקרא לה כל הזמן גם כאשר הטקסט אינו משתנה נוכל לראות ריצוד קל על הצג. כדי לפתור את הבעיה אנחנו שומרים משתנה נוסף שיכיל את הטקסט הקודם שהוצג. במידה והטקסט שונה רק אז נבצע ניקוי של הצג.
myLCD.setCursor קובעת מאיפה אנחנו מתחילים לכתוב כאשר הפרמטר הראשון הוא המיקום ב-X והשני ב-Y (מספר השורה). הצג שברשותנו הוא 16×2 כלומר שתי שורות שבכל שורה קיימים 16 תווים.
myLCD.write מציגה את הטקסט על הצג.

עכשיו נריץ את התוכנית החדשה.
*נשים לב כי הוספנו ספרייה חדשה לפרויקט ולכן יש לבצע תחילה (לאחר השמירה) בניה מחדש של הפרויקט ע"י שימוש בכפתור השני בסרגל הכלים, כפתור ה-install/build.

נתקדם צעד נוסף והפעם נרצה שצבע התאורה של המסך ישתנה בהתאם לעוצמת תאורת הסביבה. לשם כך נוסיף סנסור חדש לאוסף, Light Sensor.
את הסנסור החדש נחבר לכניסה A1 ונבצע את השינויים המתאימים כך שהתוכנית תראה בצורה הבאה:

var mraa = require('mraa');
var LCD  = require ('jsupm_i2clcd');
console.log("LCD + Light");

function delay(ms) {
    var now = new Date().getTime();
    while(new Date().getTime() < now + ms); 
}

var myLCD = new LCD.Jhd1313m1(0);
var analogPin0 = new mraa.Aio(0);
var analogPin1 = new mraa.Aio(1);
var LED = new mraa.Pwm(3);
var lcdMessage = "";

function setup() {
    LED.enable(true);
    myLCD.setColor(255, 128, 0);
}

function loop() {
    var analogValue = analogPin0.read();
    var value = analogValue / 1023.0;
    LED.write(value);

    var light = analogPin1.read();
    var lightValue = (light / 1023.0) * 255;
    myLCD.setColor(lightValue, 0, 255 - lightValue);
    
    var lastLcdMessage = lcdMessage;
    lcdMessage = "Brightness: " + (value.toFixed(2) * 100) + "%";
    if (lcdMessage != lastLcdMessage)
    {
        myLCD.clear();
    }
    myLCD.setCursor(0,0);
    myLCD.write(lcdMessage);
    delay(100);
}


setup();

while (1) {
    loop();
}

 בפונקציה loop הוספנו דגימה של הסנסור המחובר ל-A1, חילקנו בערך המקסימלי וכפלנו ב 255 שזהו הערך המקסימלי עבור ערכי R,G,B. לאחר חישוב הערך ביצענו קריאה לפונקציה setColor של הצג עם הערך שהתקבל. ניתן לשחק עם הערכים איך שרוצים ואנחנו בחרנו שהצבע האדום יהיה ביחס ישיר לערך שנדגם כלומר ככל שיש יותר אור כך ערכו של האדום יהיה גבוהה יותר.
את ערכו של הירוק קבענו כ 0 ואת ערכו של הכחול קבענו ביחס הפוך לעוצמה, כלומר ככל שיש יותר אור כך ערכו יקטן.
עכשיו הריצו את התוכנית ושנו את עוצמת האור שהחיישן מרגיש ושימו לב כיצד התאורה משתנה.

 אחד היתרונות הגדולים של גלילאו הוא היכולת המובנית להשתמש בתקשורת.
כל התוכניות שאנחנו מריצים על גבי הלוח בעזרת Intel XDK רצות על גבי node.js כך שניתן להקים תקשורת בקלות.
בדוגמא הבאה נבצע שינוי בתוכנית כך שכל המידע הנדגם ע"י הלוח יישלח ללקוח המחובר מרחוק בעזרת תקשורת TCP שנקים על הלוח.

קוד התוכנית:

var net = require("net");
var mraa = require('mraa');
var LCD  = require ('jsupm_i2clcd');

console.log("LCD + Light + TCP");

function delay(ms) {
    var now = new Date().getTime();
    while(new Date().getTime() < now + ms); 
}

var myLCD = new LCD.Jhd1313m1(0);
var analogPin0 = new mraa.Aio(0);
var analogPin1 = new mraa.Aio(1);
var LED = new mraa.Pwm(3);
var lcdMessage = "";
var mySocket = null;
var overrideLED = false;

function setup() {
    LED.enable(true);
    myLCD.setColor(255, 128, 0);
}

function sendData(data)
{
    if (mySocket != null && mySocket.writable == true)
    {
        mySocket.write(data);
    }       
}

function main() {
    setInterval(function () {    
        var analogValue = analogPin0.read();
        var value = analogValue / 1023.0;
        if (overrideLED)
        {
            LED.write(0);
        }
        else
        {
            LED.write(value);            
        }

        var light = analogPin1.read();
        var lightValue = (light / 1023.0) * 255;
        myLCD.setColor(lightValue, 0, 255 - lightValue);

        var lastLcdMessage = lcdMessage;
        lcdMessage = "Brightness: " + (value.toFixed(2) * 100) + "%";
        if (lcdMessage != lastLcdMessage)
        {
            myLCD.clear();
        }
        myLCD.setCursor(0,0);
        myLCD.write(lcdMessage);
        sendData("B" + (value.toFixed(2) * 100) + "\r\n");
        sendData("L" + lightValue + "\r\n");        
    }, 100);
}

var server = net.createServer(function (socket) {
    console.log("Connection from " + socket.remoteAddress);

    socket.on('end', function() {
        console.log('client disconnected');
    });
    socket.on('data', function(data) {
        console.log(data.toString());
        if (data == "LED0")
        {
            overrideLED = false;
        }
        else if (data == "LED1")
        {
            overrideLED = true;            
        }
    });
    socket.on('close', function(err) {
        console.log("Client Disconnected");
        if (err == true)
        {
            console.log("With error");
        }
    });
    socket.on('error', function(err) {
        console.log("We had error (" + err + ")" );
    });
    
    mySocket = socket;
});

server.listen(7000);

setup();

main();

נשים לב שבוצעו מספר שינויים בקוד המקורי.
לפונקציה loop שינינו את השם ל main ועברנו לשיטה מספר 1 (כמו בתוכנית blink הראשונה) שעושה שימוש בטיימר. שינוי זה נעשה כדי לא לתקוע את התוכנית על הפונקציה הזו ולאפשר לשאר הרכיבים בתוכנית
המטפלים בתקשורת לעבוד בצורה תקינה.
בהמשך יצרנו שרת ע"י net.createServer שמטפל בארועי התקשורת השונים הכוללים מידע נכנס, ניתן, וכו'
כאשר לקוח מתחבר ללוח אנחנו מעדכנים את המשתנה mySocket שדרכו נוכל לתקשר מול הלקוח.

תוכנת הלקוח שלנו כתובה ב-C# וניתן להוריד אותה כאן.

יש להקליד את כתובת הלוח בתיבה ואת הפורט. לאחר לחיצה על connect יתבצע חיבור ללוח והוא יתחיל להזרים מידע לאפליקציה.
בשעון השמאלי נראה את הערך שנקרא מהפוטנציומטר המשפיע על עוצמת הלד ובשעון הימני נראה את הערך הנקרא ע"י חיישן האור המשפיע על התאורה האחורית של הצג.
לחיצה על כפתור Turn LED Off תעקוף את ערך הפוטנציומטר ותקבע את ערכו ל 0 כך שהוא יראה כבוי. לחיצה נוספת על הכפתור תאיר את הלד על פי עוצמת הפוטנציומטר.

במדריך זה למדנו איך להשתמש ב Intel XDK וכתיבת תוכניות ב-Javascript והרצתן על גבי לוח הגלילאו.
ראינו את הדומה והשונה בין תוכנית Arduino סטנדרטית ואף השתמשנו בתקשורת בסיסית לקריאה ושליטה על הלוח.

 

למדתם? התרשמתם לטובה? נשמח לשמוע מה דעתכם בתגובות!