BeagleBone Development Environment

במאמר הראשון בנושא הצגתי את הסביבת הפיתוח שמגיעה עם הלוח, Cloud 9 זו סביבה באמת מעניינת עם רעיון לא רע בכלל, אבל הסביבות הותיקות הרבה יותר מתוחכמות ממנה, כנראה שצריך לתת לה עוד זמן, נחזור למקורות ונבנה את הסביבה ע"ג Eclipse ובעזרת קוד ב C / C++ נשחק עם הלוח, בדומה למאמר הקודם גם פה נתעסק עם הקבצים בספריית Sys שבעזרתם נשלוט על הרכיבים בלוח.

שימו לב - סביבת ה Host הוקמה ע"ג Fedora 14.

הקמת ה Host

לפני שנתחיל עם ה Eclipse חשוב מאוד להתקין את ה ToolChain של Arm בשביל שנוכל לבנות תוכניות שתואמות את הארכיטקטורה של הלוח, באתר של Angstrom אפשר להוריד את ה ToolChain שמתאים ל Distribution, או ניתן להוריד מ  CodeSourcery את ה ToolChain הכללי מכאן , אבל זה לא ממולץ ועלול לגרום לתקלות בגלל הפער בין ה  ToolCahin שעל הלוח מול ה ToolChain שב Host, מומלץ להשתמש ב ToolChain שזהה למה שמותקן על הלוח, נפתח את הקובץ:

#: tar -xvf /home/fedora/download/angstrom-gnueabi-arm.tar

נפרוס את הקובץ לאיזה תיקייה שנרצה, לאחר מכן נוסיף את התיקיית Bin בתיקייה שיצרנו להגדרות ה PATH של המערכת:

#:export PATH=/opt/angstrom/arm/bin/:$PATH

נפתח פרויקט חדש ב Eclipse , צריך לשנות את הגדרות ה Compiler ל Compiler שמגיע עם ה ToolChain, זה לא נגמר רק עם ה Compiler  חשוב לשנות גם את ה Linker וה Assembler , נלחץ על Properties->C/C++ Build->Settings ונשנה מ gcc הקלאסי ל arm-angstrom-linux-gnueabi-gcc כפי שניתן לראות בדוגמה:

Remote Control

על מנת שנוכל לעבוד מרחוק יש להוריד Plugin עבור ה Eclipse שנקרא Remote System Explorer , יש ללחוץ על Install New Software בתפריט ה About ולבחור את הרכיבים כפי שמופיע בדוגמה:

לאחר ההתקנה יש להפעיל את ה Eclipse מחדש, ללחוץ על בתפריט Window ->Show View -> Other וללחוץ על תיקיית  Remote Settings ולבחור ב Remote Systems.

נוספת תגית Remote Systems בסביבה של Eclipse צריך להוסיף חיבור חדש על מנת שנוכל לדבר עם הלוח בעזרת SSH כפי שניתן לראות ברצף התמונות הבאות:

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

Remote Debugging

ניתן לבצע Remote Debugging בעזרת GDB שמגיע עם ה ToolChain שבלוח ועם זה שהורדנו למחשב ה Host, העבודה עם הכלי מתחלקת ל 2 חלקים, החלק הראשון נקרא gdbserver שאותו מפעילים על התוכנה שנמצאת בלוח בעזרת חיבור ה SSH כפי שניתן לראות בדוגמה:

#: gdbserver 192.168.1.7:12345 simpleApp

החלק השני הוא להגדיר את ה gdb על ה Host ב Eclipse, יש ללחוץ על תגית Run->Debug Configuration ולייצר קונפיגורציה חדשה עבור Remote Application.

לאחר מכן יש ללחוץ על תגית Debugger ולשנות ל Debugger שהגיע עם ה ToolChain:

אפשר להתחיל לעשות Debug על הלוח:

קוד

זהו הסביבה מוכנה לעבודה, הקוד הראשון שנכתוב מאוד פשוט, ע"ג ה Beaglebone יש 4 Leds מובנים ואיתם נשחק, בגדול אנחנו הולכים לפתוח קובץ לכתוב לתוכו ערך ולסגור אותו בעזרת שפת C כפי שניתן לראות בדוגמה הבאה:

#include <stdio.h>
#include <stdlib.h>


int main(void) {

FILE *handler = NULL;

//location of the led2 file in sys folder
char *ledFlocation = "/sys/class/leds/beaglebone::usr2/brightness";

//just a flag for toggle
int i = 0;

while(1)
{
//if we get the handler
if((handler = fopen(ledFlocation,"r+")) != NULL)
{
if(i == 0)
{
//light on
fwrite("1",sizeof(char),1,handler);
i=1;
}
else
{
//lights off
fwrite("0",sizeof(char),1,handler);
i = 0;
}

}
//close the file - very imported
fclose(handler);
sleep(1);
}
return 0;
}

סיכום:

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

בהצלחה...

BeagleBone And Arduino

אז אחרי ההכרות הבסיסית עם BeagleBone אפשר לומר שניתן לעשות איתו הכול, היתרון המרכזי כמובן זה המעבד ה 32 Bit וה MMU שמאפשרים לנו להריץ מערכות הפעלה מתקדמות כמו Linux וכמובן לחבר רכיבים מתוחכמים יותר בעזרת תקשורות רבות שבאות עם הלוח, במאמר הזה אני יסביר כיצד ניתן לדבר עם ה Arduino בעזרת פקודות פשוטות ב SSH.

יש לחבר את הלוח לרשת , לאתר את הכתובת שלו ולהיכנס בעזרת Putty.

דרישות:

• Beaglebone
• Arduino Uno
• Led
• 330ohm Resistor
• Wires

לפני שנחיל לדבר חשוב לזכור שכל פין ב BeagleBone יכול לעבוד ב 8 מצבים שונים, כלומר ניתן לנתב את הפינים לכל מיני רכיבים בלוח לדוגמה הכניסות של ה Uart יכולות לשמש במצב אחר עבור I2C לכן חשוב למצוא את המצב המתאים על מנת שנוכל לדבר סיראלית, תחילה נמצא את הפינים עבור Uart1 ב Expansion Header:

נדאג שה Arduino יקבל חשמל דרך הכניסות של ה 5V וה GND שב BeagleBone, שימו לב מומלץ לעבוד עם ספק כח חיצוני ולשנות את ה PIN של ה 5 V מ 7 ל 5, לאחר מכן נמצא את ה Mode שאותו צריכים להגדיר לפינים שנבחרו על מנת שידברו עם רכיב ה Uart1 שנמצא בלוח.

נגדיר את כניסת ה TX ב BeagleBone שתתחבר לכניסה RX  שב Arduino:

root@beaglebone:~# echo 0 > /sys/kernel/debug/omap_mux/uart1_txd

root@beaglebone:~# cat /sys/kernel/debug/omap_mux/uart1_txd
name: uart1_txd.uart1_txd (0x44e10984/0x984 = 0x0000), b NA, t NA
mode: OMAP_PIN_OUTPUT | OMAP_MUX_MODE0
signals: uart1_txd | mmc2_sdwp | d_can1_rx | i2c1_scl | NA | pr1_uart0_txd_mux1 | NA | gpio0_15

ניתן לראות שה Pin מוגדר על Mode 0 ומצביע על GPIO_15.

נגדיר את כניסת ה RX ב BeagleBone שתתחבר לכניסה TX שב Arduino:

root@beaglebone:~# echo 20 > /sys/kernel/debug/omap_mux/uart1_rxd

root@beaglebone:~# cat /sys/kernel/debug/omap_mux/uart1_rxd
name: uart1_rxd.uart1_rxd (0x44e10980/0x980 = 0x0020), b NA, t NA
mode: OMAP_PIN_INPUT_PULLDOWN | OMAP_MUX_MODE0
signals: uart1_rxd | mmc1_sdwp | d_can1_tx | i2c1_sda | NA | pr1_uart0_rxd_mux1 | NA | gpio0_14

ניתן לראות שה Pin מוגדר על Mode 0 ומצביע על GPIO_14.


בגרסת ה Angstrom שמגיעה עם הלוח יש כלי נחמד שנקרא Minicom שמאפשר לנו לשלוח ולקבל מידע דרך חיבור סיראלי, יש להגדיר את התוכנית על ה Device שמייצג את ה Uart ב Linux במקרה שלנו ttyO1 שווה ל Uart1 לא לשכוח להריץ ב Terminal מקביל.

root@beaglebone:~# minicom -b 9600 -D /dev/ttyO1

יאללה תתחילו לדבר:

מה שנשאר לנו הוא להריץ את הפקודה המתאימה:

//say to arduino to active the led

root@beaglebone:~# echo C1O > /dev/ttyO1

//say to arduino to deactive the led

root@beaglebone:~# echo C1F > /dev/ttyO1

נפתח 2 Terminals במקביל על מנת לראות את מה שמקבל ה Arduino:

קוד Arduino:

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

//*** Serial Connection Demo Arduino Listener ***
//*** proxytype.blogspot.com                  ***

//GPIO pin 12
int ledpin = 12;

//buffer counter
int counter = 0;

//buffer
char cmd[4];

//flush buffer
void flushArr()
{
     for(int i = 0; i < 3; i++)
   {
       cmd[i] = 0;
   }
 
}

//set pin status
void setled(int _status)
{
  digitalWrite(ledpin, _status);
}

void setup()
{
  Serial.begin(9600);
}

void loop()
{

  while (Serial.available() > 0)
  {
    cmd[counter] = Serial.read();
 
    //write the char output for diagnose
    Serial.print(cmd[counter]);
    Serial.print("\n");
 
     counter = counter + 1;
 
    delay(10);
    }
 
    //C1O set led on
     if(cmd[0] == 'C' && cmd[1] == '1' && cmd[2] == 'O')
      setled(HIGH);
 
   //C1F set led off
  else if(cmd[0] == 'C' && cmd[1] == '1' && cmd[2] == 'F')
      setled(LOW);

   if(counter > 2)
   {
      counter =0;
       flushArr();
   }
 
   delay(10);
}

מבנה סופי

סרט הדגמה

סיכום:

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

זיווג משמיים!

BeagleBone Guide

לאחר שגילנו את ה Arduino הגיע הזמן להתקדם ללוחות יותר מתקדמים, משפחת הלוחות הבאה נקראת BeagleBoard, מדובר על Open Hardware בדומה ל Arduino אבל הפעם המעבד יותר רציני מהמעבד ה 8 ביט שעליו עבדנו עד עכשיו אלא על מעבד 32 ביט מבוסס Arm שכבר יכול להריץ מערכות הפעלה מתקדמות כמו Linux  ו Android וגם חומרה חזקה יותר שבעצם הופכות את הלוח ל"מחשב" לכל דבר.

משפחת BeagleBoard:

BeagleBoard

הלוח הקלאסי והותיק בסדרה עם מעבד AM37X במהירות 720 MHZ בסביבות 125 דולר ליחידה.

לאתר היצרן.

BegaleBoard-xM

הלוח המורחב של המשפחה עם מעבד OMAP3530 במהירות 1000 MHZ בסביבות 149 דולר ליחידה.

לאתר היצרן.

BeagleBone

לוח שדומה בהתנהגות שלו ל Arduino ועליו נתמקד במאמר זה, הוא מגיע עם מגוון כניסות ותקשורות כמו I2C, Uart ו Spi, מעבד AM335X במהירות 720 MHZ ובסביבות 89 דולר ליחידה.

לאתר היצרן.

נעים להכיר BeagleBone

הלוח הראשון שעליו אתמקד הוא  BeagleBone ששונה במבנה שלו משאר הלוחות במשפחה ומאפשר לחבר אליו עשרות חיבורים שונים ושימוש בתקשורות הנפוצות ביותר בתעשייה, רק כדי להבין את ההבדלים ניתן לראות כמה המעבד  ATmega328P 8 Bit של Arduino נראה פשוט מול המעבד Cortex A8 32 bit:

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

ע"ג הלוח יש 2 סטים של כניסות , בכל סט 46 כניסות שמאפשרות לנו לתקשר עם רכיבים חיצוניים.

צעדים ראשונים

הלוח מגיע עם כרטיס MicroSD שמותקן עליו גרסת Angstrom מוכנה לשימוש, כל מה שצריך לחבר למקור כוח של 5 V ואפשר לרוץ, אם נרצה לבנות את ה MicroSD מחדש ולהתקין את העדכונים האחרונים ניתן לעקוב אחרי המדריך שמופיע באתר היצרן, בשביל להתחיל לדבר עם הלוח יש לחבר ולמצוא אותו ברשת בעזרת Port Scanner או ברשימת הכתובות של ה DHCP.

ניתן להשתמש בהמון סביבות פיתוח ב BeagleBone אבל כחלק מגרסת ה Angstrom שמגיעה עם הלוח קיימת סביבה שנקראת Cloud 9 שבעזרת ניתן לכתוב קוד ב Javascript ולהריץ אותו על הלוח, הסביבה עצמה נגישה דרך ה Browser ומאפשרת לפתח מכל מקום ישירות על הלוח.

קוד

ניצור קובץ חדש עם סיומת js ,לפני שנתחיל לכתוב את הקוד מומלץ להעתיק (בעזרת התחברות ב SSH) את הקובץ bone.js ל workspace שלכם, הקובץ נמצא בתיקייה  usr/lib/node-modules/bonescript/bone.js , הוא מכיל מיפוי עבור כל החיבורים בלוח,ובעזרת bonescript.js נבצע את הפעולות על גבי החיבורים שנבחרו כמובן שניכנס ללולאה אינסופית בעזרת הפונקציה setInterval בדומה ל loop ב Arduino.

//init scope
var b = require('bonescript');
var bone = require('/var/lib/cloud9/bone') ;

//set extensions pins
var ledPin = bone.bone.P9_23;
var ledPin2 = bone.bone.P9_25;

b.pinMode(ledPin, b.OUTPUT);
b.pinMode(ledPin2, b.OUTPUT);

var state = b.LOW;
b.digitalWrite(ledPin, state);
b.digitalWrite(ledPin2, state);

//enter loop
setInterval(toggle, 1000);

function toggle() {
    if(state == b.LOW)
    {
     state = b.HIGH;
     b.digitalWrite( ledPin, b.LOW);
     b.digitalWrite( ledPin2,  b.HIGH);
    }
    else
    {
      state = b.LOW;
      b.digitalWrite(ledPin, b.HIGH);
      b.digitalWrite(ledPin2, b.LOW);
    }
}

חשוב לזכור שאנחנו לא צורבים את התוכנית על הלוח בדומה ל Arduino אלא שבמקרה של Beaglebone אנחנו עובדים עם קבצים ששומרים על כרטיס הזיכרון ובעזרת ה Linux מפעילים אותם, במקרה שנרצה להריץ הקוד שלנו מחוץ לסביבת הפיתוח נרשום את הפקודה הבאה ב Terminal:

#:node yourscript.js

מבנה סופי:

סיכום:

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

אחלה שדרוג...