Arduino Yun - Starting Guide

עד עכשיו ראינו 2 סוגים של לוחות פיתוח, הראשון היה Arduino שמבוסס על מעבד פשוט ללא מערכת הפעלה, לעומתו ראינו את BeagleBone ואת Raspberry PI שמבוססים על מעבדים יותר מתוחכמים שמריצים Linux, מפתחי Arduino לא יכלו להיות אדישים והוציאו דגם חדש שמשלב בתוכו את 2 העולמות.

הוא מכיל 2 מעבדים, הראשון והמוכר ATmega 328u4 במהירות 16MHZ ו 32KB של זיכרון ,הוא אחראי על העבודה מול החיבורים הדיגטליים והאנלוגים המקוריים שיש בגרסת ה Uno הותיקה, המעבד השני הוא Atheros AR 9331 שמבוסס על ארכיטקטורת MIPS במהירות 400Mhz עם 64MB של זיכרון, הוא אחראי על שאר ה Peripherals כמו הרשת הקווית ,האלחוטית ,כרטיס הזיכרון וה USB ,הלוח מריץ מערכת OpenWRT שכתבתי עליה בעבר.

דרישות

• Arduino Yun
• Led
• 330ohm Resistor
• Wires

בגודל של Uno

הפעלה ראשונית

הלוח מגיע מוכן, מה שנשאר לעשות הוא לחבר אליו חשמל ולהתחבר ל Access Point שהוא יוצר אוטומטית, נפתח את הדפדפן ונכניס את הכתובת של ה Default Gateway שקיבלנו (במקרה שלי 192.168.201.223), דרכה נגיע לממשק הניהול.

הסיסמא ההתחלתית היא arduino

הממשק עצמו מאוד פשוט, דרכו ניתן להגדיר את התקשורת WIFI, אבל יש בו אפשרות נוספת שכדאי להכיר שנקראת Rest API , זה המנגנון דרכו נדבר עם המעבד ATmega דרך שרת Http ששולט על הפינים כפי שנראה בהמשך.

חלק קטן מ OpenWRT

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

טירוף...

Bridge

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

בעזרת פרטוקול Http ושרת Web, נוכל לשלוט על הפינים בעזרת מבנה Url, לדוגמה נניח שנרצה להפוך את Pin 13 ל OutPut נקרא לכתובת במבנה מסויים שברגע שתגיע לשרת הוא יחתוך אותה ויפעל בהתאם כפי שניתן לראות בדוגמאות הבאות:

הגדרת הרגל כ Input / Output:

http://arduino.local/arduino/mode/13/output

כתיבת ערך לרגל דיגיטלית:

http://arduino.local/arduino/digital/13/1

קריאת ערך מרגל דיגיטלית:

http://arduino.local/arduino/digital/13

כתיבה ערך לרגל אנלוגית:

http://arduino.local/arduino/analog/2/128

קריאת ערך מרגל אנלוגית:

http://arduino.local/arduino/analog/2

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

• Putty - נתחבר ל Arduino Yun בעזרת SSH.
• WinSCP - העברת קבצים בין המחשב האישי ל Arduino Yun.

נפתח Notepad ונרשום את הקוד הבא:

#Arduino Yun blink example using Bridge with Python

#proxytype.blogspot.com

#getting Thread function from Thread class

from threading import Thread

#add Libraries

import urllib2

import time

#selected Pins

PIN = 7

#set pins output/input

response = urllib2.urlopen('http://localhost/arduino/mode/' + str(PIN) + '/output')

print response.read()

def main(n):

    #flag

    Status = False

    while True:

if Status == False:

Status = True

response = urllib2.urlopen('http://localhost/arduino/digital/' + str(PIN) + '/1')

print response.read()

else:

Status = False

response = urllib2.urlopen('http://localhost/arduino/digital/' + str(PIN) + '/0')

print response.read()

time.sleep(n)

#start in new thread, send second to sleep

t = Thread(target=main, args=(1,))

t.start()

נשמור את הקובץ ונעביר אותו ל Yun בעזרת WinSCP, ואח"כ נתחבר ל Terminal בעזרת SSH ונריץ את התוכנית:

סרט לדוגמה

סיכום

הלוח הזה לוקח את כל העסק צעד אחד קדימה במחיר יחסית שפוי של 60$, ומאפשר לנו לכתוב פרוייקטים יותר מורכבים ועדיין להישאר באותה מסגרת נוחה של Arduino, בהמשך נראה כיצד להשתמש בספריות היעודיות של ה Yun שמאפשרות לגשת למשאבי ה Linux מבלי לעזוב את ה IDE.

יותר שכל באותו מקום...

Raspberry Pi - Starting Guide

אם חשבתם ש Raspberry PI יעבור לידי ואני לא אתייחס אליו אז טעיתם, הלוח הזה שינה את כללי המשחק בכל הקשור למערכות Embedded ו SOC, הוא זול ,פשוט ומגיע עם מגוון רחב של חיבורים, אין משהו שלא עשו איתו ממערכות פשוטות למחשבי על, הוא תוכנן ע"י ארגון צדקה בשם Raspberry Pi Foundation שמטרתו ללמד מדעי המחשב באופן חופשי בעולם.

הסדרה מכילה 3 דגמים עם את אותו מעבד ARM 700MHZ (בנתיים) וההבדלים העיקריים הם בציוד היקפי (Peripherals) שמשתנים מדגם לדגם ומשפיעים על המחיר.

www.sparkfun.com

דרישות

• Raspberry PI Model B
• SDCard 8 GB
• TFT Monitor
• Keyboard + Mouse
• LED
• 330ohm Resistor
• Breadboard
• Wires

שימו לב!

• יש לחבר לספק 5V בלבד!
• חשוב לזכור שהפינים של ה 5V מוגבלים עד 300ma וה 3.3V עד 50ma.

התקנה

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

http://www.raspberrypi.org/downloads/

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

https://www.sdcard.org/downloads/formatter_4/

לאחר סיום הפורמט נפתח את קובץ ה Zip ונעתיק את התוכן שלו ל SDcard, נחבר מקלדת ומסך ואפשר לומר שסיימנו, הלוח מגיע עם כניסת HDMI שניתן לחבר לכל טלויזיה או מסך וחיבור S-Video סטנדרטי למסכים קצת יותר פרימיטביים לצורך הדוגמה אני משתמש במסך בגודל 5 אינץ שמתאים בעיקר לרכב שרכשתי מ DX תמורת 40$ היתרון שלו על פני שאר המסכים שניתן גם לחבר VGA, בדר"כ המסכים האלה מגיעים ללא ספק כוח ודורשים 12V אבל הצלחתי להפעיל אותו ב 9V ואני מאמין שאפשר גם בפחות.

סיני זול שעושה את עבודה.

במהלך ה Boot של הלוח ניתן ללחוץ Shift 3 על מנת להעביר את התצוגה ל S-Video ב PAL ומשם להמשיך בהתקנה, קובץ ההתקנה מכיל מספר distributions של Linux מותאמות ל Raspberry Pi, אבל מומלץ להשתמש ב Raspbian שהיא הפופלרית ביותר.

שתו קפה יש זמן...

בסיום ההתקנה הלוח יעשה Boot ויעלה מסך הגדרות הם מספר אפשרויות, קודם כל מומלץ להחליף את סיסמאת ה Default שהיא raspberry עבור משתמש PI, ניתן להגדיר Overclock ועוד כל מיני דברים, תמיד אפשר לחזור למסך הזה ע"י הפקודה raspi-config עם Sudo.

Overclock - נחמד!

בסיום יעלה לנו הטרמינל הרגיל של Linux, בעזרת הפקודה startx נעבור לממשק חלונאי:

ואוו...

קוד

המערכת מוכנה ואפשר להתחיל לכתוב את הקוד הראשון, בעבר הדגמתי כיצד לתכנת פינים ב BeagleBone וזה לא כלכך שונה מה PI, כי נחזור על אותה קלישאה ישנה שהכל ב Linux זה קובץ וכל מה שנשאר זה לפתוח אותו ולכתוב בו ערך באיזה שפה שנרצה, במקרה של ה PI שפת ה Python מגיעה כחלק מהמערכת אבל לפני הקוד חשוב להכיר את הפינים עצמם.

26 פינים שחלקם עם שימוש נוסף

26 פינים שבחלקם ניתן לעשות יותר משימוש אחד, ניתן לעבוד עם מספר ממשקים שונים (UART,SPI,I2C), במערכת מגיעה סביבת פיתוח פשוטה של Python שנקרא IDLE שבעזרתו נכתוב את הקוד, אם לא בא לכם לעבוד ישירות על הלוח ניתן להתחבר אליו בעזרת SSH.

#add Libraries

import RPi.GPIO as GPIO

#use board pins

GPIO.setmode(GPIO.BOARD)

#selected pin

pin = 7

#set GPIO as output

GPIO.setup(pin, GPIO.OUT)

#set flag false

status = False

while True:

if status == False:

GPIO.output(pin,GPIO.LOW)

status = True

else:

GPIO.output(pin,GPIO.HIGH)

status = False

x = raw_input('Press Key!')

מבנה סופי

סרט הדגמה

סיכום

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

יש פטל?

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 שעל הלוח.

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

Arduino Button Guide

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



דרישות:

• Arduino Uno
• Arduino Prototype Shield
• Button
• Led
• 330Ohm Resistor 
• 10K Ohm Resistor
• Bridges

The Button
הכפתורים ב Arduino עובדים על רעיון של רמות מתח, ה Pin שאליו מחובר הכפתור מאזין למתח וכאשר הוא לחוץ מזהה ה Arduino שהוא במתח נמוך ומגדיר אותו כ LOW כמו שתראו בקוד בהמשך... קיימת בעיה כאשר הכפתור לא לחוץ , ה Pin מקבל מתח כל הזמן ועלול לגרום לתופעות משונות על מנת להבטיח אמינות יש להשתמש ב Resistor 10K.

מבנה סופי

קוד:

//set the pins
int ledpin = 12;
int inpin = 3;

//set val for checking
int val =0;

 void setup()
 {
   //set the pin mode
   //led as output
   //button as input
   pinMode(ledpin,OUTPUT);
   pinMode(inpin,INPUT);
 }

 void loop()
 {
   val = digitalRead(inpin);

   //if val is high 
   //the button is not press
   //the led go off else go on
   if(val == HIGH)
   {
     digitalWrite(ledpin,LOW);
   }
   else
   {
     digitalWrite(ledpin,HIGH);
   }
 }

סרט הדגמה:

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

push the button!

Arduino Leds Guide

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

עבודה עם Led סטנדרטי

דרישות:

• Arduino Uno
• Wire
• Resistors 330 Ohm
• Bridges

ל Leds הסטנדרטים יש 2 רגליים (+\-) עבור המתח, את רגל החיובית ניתן לזהות בכך שהיא הרגל הארוכה, לה מתחבר נגד 330 Ohm שמתחבר ל Digital Pin , את הרגל הקצרה נחבר לכניסת GND ב Arduino.

ניתן להשתמש ב Bridges (גשרים) על מנת לחבר את כל הלדים לנקודת GND אחת.

מבנה סופי

קוד הדגמה:

//set arduino pins

int pinA =5;

int pinB =6;

int pinC =7;

int pinD =8;

int pinE =9;

int pinF =10;

int pinG =11;

int pinH =12;

int pinI =13;

void setup()

{

  //set pins as ouput

  pinMode(pinA,OUTPUT);

  pinMode(pinB,OUTPUT);

  pinMode(pinC,OUTPUT);

  pinMode(pinD,OUTPUT);

  pinMode(pinE,OUTPUT);

  pinMode(pinF,OUTPUT);

  pinMode(pinG,OUTPUT);

  pinMode(pinH,OUTPUT);

  pinMode(pinI,OUTPUT);

}

void loop()

{

  

  //change each led  to high => on and low => off 

  //using delay between switching

  digitalWrite(pinA,HIGH);

  delay(100);

  digitalWrite(pinA,LOW);

  delay(100);

  

   digitalWrite(pinB,HIGH);

  delay(100);

  digitalWrite(pinB,LOW);

  delay(100);

  

   digitalWrite(pinC,HIGH);

  delay(100);

  digitalWrite(pinC,LOW);

  delay(100);

  

  

   digitalWrite(pinD,HIGH);

  delay(100);

  digitalWrite(pinD,LOW);

  delay(100);

  

   digitalWrite(pinE,HIGH);

  delay(100);

  digitalWrite(pinE,LOW);

  delay(100);

  

    

   digitalWrite(pinF,HIGH);

  delay(100);

  digitalWrite(pinF,LOW);

  delay(100);

  

    

   digitalWrite(pinG,HIGH);

  delay(100);

  digitalWrite(pinG,LOW);

  delay(100);

  

    

   digitalWrite(pinH,HIGH);

  delay(100);

  digitalWrite(pinH,LOW);

  delay(100);

  

    

   digitalWrite(pinI,HIGH);

  delay(100);

  digitalWrite(pinI,LOW);

  delay(100);

  

    

}

עבודה עם Led RGB

דרישות:

• Arduino Uno
• Wire
• 3 Resistors 330 Ohm
• RGB Led

פה העסק קצת שונה עבור כל ערוץ צבע (שבעצם רגל) מתחבר ל Resistor , הרגל הארוכה מסמנת כרגל השלילית שמתחברת ל GND.

מבנה סופי

יאללה דיסקו!

קוד דוגמה:

//set pins in the arduino

const int RED_LED_PIN = 1;

const int GREEN_LED_PIN = 2;

const int BLUE_LED_PIN =3;

//init value for each channel

int red = 0;

int green = 0;

int blue = 0;

//delay

const int display_timeout = 100;

void setup(){}

void loop()

{

  

  //change the green channel

  // mixing with the red channel

      for(green = 0; green <= 255; green+=5)

    {

       red = 255 - green;

       analogWrite(GREEN_LED_PIN,green);

       analogWrite(RED_LED_PIN,red);

       delay(display_timeout);

    }

    

  //change the blue channel

  // mixing with the green channel

      for(blue = 0; blue <= 255; blue+=5 )

    {

       green = 255 - blue;

       analogWrite(BLUE_LED_PIN,blue);

       analogWrite(GREEN_LED_PIN,green);

       delay(display_timeout);

    }

     

    

  //change the  red channel

  // mixing with the blue channel

      for(red = 0; red <= 255; red+=5)

    {

       blue = 255 - red;

       analogWrite(RED_LED_PIN,red);

       analogWrite(BLUE_LED_PIN,blue);

       delay(display_timeout);

    }

    

}

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


סרט הדגמה:

Arduino Starting Guide

מי שלא מכיר אז כדאי שיכיר מדובר בדבר החם ביותר שהאטלקים המציאו אחרי Ferrari, לוח קטן ופשוט שנועד במקור לעזור לתלמידים באלקטרוניקה אי שם באיטליה, הוא הפך לפופלרי בזכות הגדרתו כ Open Hardware ובעצם מאפשר לכל אחד לבנות אותו באיזו צורה שהוא רוצה וכמובן בעלות נמוכה , אפשר למצוא מגוון רחב של לוחות מבוססים על מעבד ATmega:

ניתן למצוא גרסאות מבוססות על ARM Cortex M3 32Bit.

מה אפשר לעשות איתו?

בגדול הוא בעיקר ללימוד ולמימוש קונספטים באלקטרוניקה ופיתוח עבור מערכות משובצות מחשב, ניתן לחבר אליו מגוון רכיבים כמו חיישנים, מנועים ואחסון ולדגום אותם בעזרת חיבור סיראלי (RS-232) , ניתן להלביש עליו רכיבים ייעודיים הנקראים Shields שלוקחים את ה Arduino צעד קדימה , מדובר על לוחות שמתלבשים כמו חליפה על חיבורי ה IO והחשמל שבלוח ומאפשרים לנו לעבוד על רכיבים קצת יותר מורכבים  כמו   GPS , BlueTooth, Wifi, Ethernet, LCD וכו'.

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

המפתחים של Arduino נתנו לנו סביבה חינמית לפיתוח שמבוססת על שפה שמזכירה מאוד את C אבל הרבה יותר פשוטה, לדוגמה כל תוכנית מתחילה עם הפונקציה Setup שבעצם מקבילה ל Init בשפות אחרות, נאתחל בה את הערכים בתוכנית , ואח"כ תרוץ הפונקציה Loop שהיא לולאה אינסופית שמטפלת ב IO.

int buttonPin = 2;

void setup()

{

  Serial.begin(57600);

  pinMode(buttonPin, INPUT);

}

void loop()

{

  // ...

}

התוכנית הראשונה שאני מדגים היא עבודה עם Led , התוכנית תתחבר ל Pin 13, שמוגדר כ  OnBoard Led, בנוסף נגדיר חיבור Serial על מנת להוציא הודעות למסך.

int ledPin = 13;             

void setup()

{

  pinMode(ledPin, OUTPUT);     

}

void loop()

{

  digitalWrite(ledPin, HIGH);   

  delay(1000);                 

  digitalWrite(ledPin, LOW); 

  delay(1000);                 

}

 אפשר להגיד שיש בלוח את כל הדברים שאנחנו צריכים: עבודה עם Type מגוונים כמו String, Float, Array , עבודה עם Interrupts , שעונים וכו' (לרשימת ה Reference המלאה לחץ כאן),  באמת לא חסכו , קיימים Libraries ייעודים לטיפול ב Servo , Serial, Android ועוד (לרשימה הרשמית לחץ כאן) , חינמי ו Open Source.

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

 Shell לצפיה בהודעות שחוזרות.

סיכום (איזו התרגשות!):

בהחלט מוצר נפלא שמאפשר לאנשים לא מנוסים לגעת בעולם האלקטרוניקה, כלי נהדר למימוש קונספטים בצורה זריזה וחסכונית ואפשר ללמוד ממנו המון, אין מה לומר מדובר בידידות חדשה, החלטתי לפתוח עבור הלוח הזה דף מרכזי בבלוג כי מדובר פה רק על ההתחלה ובעתיד אני אכתוב מאמרים נוספים בנושא ,אין ספק שהוא מרתק וזו הולכת להיות הרפתקה מטורפת ,אפשר לרכוש את הלוחות ברשת, מחיר ממוצע של Arduino Uno שהוא גרסה משופרת של Arduino Duemilanove הוא 100 ש"ח.

עכשיו תכלס איך זה נראה:

יאללה בלאגן...