วันพฤหัสบดีที่ 16 กุมภาพันธ์ พ.ศ. 2560

[Arduino Tutorial] Basic 01 : เล่นกับไฟกระพริบ

เอาล่ะครับ หลังจากที่ปล่อย Arduino ให้พี่น้องได้เริ่มใช้งานกัน 1 ปีกว่าๆ ที่ผ่านมา ผมก้อได้แอบเฝ้าสังเกต คนใหม่ๆ เขาเอาไปทำอะไรที่ไหนบ้าง หรือ ได้ลองใช้กันติดปัญหาบ้างไหม บางคนเอาไปใช้ได้ดี สร้างสรรค์ สิ่งประดิษฐ์ โชว์กันได้ตลอด บางคนก้อเอาไปเก็บสะสม (ทำเป็นของที่ระลึกกัน เป็นงั้นไป)
สำหรับครั้งนี้ ผมจึงอยากจะมานำเสนอ “แบบฝึกหัดใช้ Arduino สำหรับคนเริ่มต้น” เพราะว่า ทางผมได้ BB SMS และ อีเมล์มาเยอะเกี่ยวกับ “ผม (หนู เค้า ตัวเอง) อยากเริ่มต้น และอยากใช้ไมโครฯ ไม่รู้จะเริ่มต้นอย่างไงดีอ่ะ?”   (มากันทุกเพศ ทุกวัย) ส่วนมาก ผมก้อแนะนำให้อ่านตาม ตัวอย่างบ้าง หรือ แนะนำหนังสือไปบ้าง ผมกลับมาคิดๆว่า ก่อนหน้านี้ ผมเคยใช้ไมโครคอนโทรลเลอร์ตัวอื่น ผมลองผิค ลองถูกเอง ใช้เวลานานเหมือนกัน กว่าจะเข้าใจพื้นฐาน มันก้อทำให้บางคนก็เล่นทางลัด ต่อตาม ตัวอย่างเลยแต่พอไม่ work ก้อทำอะไรต่อไม่ถูก ก้อมีอีกมาก
ฉะนั้น ผมนึกๆแล้ว คงต้องมี แบบฝึกหัดง่ายๆ ฉบับชาวบ้านไม่ต้อง เคยเป็น Programming อะไรล่ะครับ เพราะว่าจะไม่ใส่คำศัพท์อะไรยากๆเลย อยากให้พื้นฐานการเขียนโปรแกรม เดี่ยวไปศึกษาการใช้ Hardware ขั้นที่สูงกันต่อไป สำหรับคนที่เพิ่งจะเริ่มต้นกับ arduino (ไม่เคยใช้ไมโครตัวอื่นมาก่อน) อยากให้ลองทำการทดลองตาม บทความนี้ สักนิดก่อนครับ

ผมสรุป แบบฝึกหัดไว้หลายตอนครับ เอาเป็นว่าคิดออกแค่นี้ก่อน ทำไปเรื่อย เดือนก้อคงจะเสร็จ
  1. เล่นกับไฟกระพริบ
  2. สื่อสารกับคอมพิวเตอร์ ด้วย arduino
  3. เล่นกับ Analog
  4. ยังนึกไม่ออก ส่ง SMS มา Vote ก้อแล้วกัน
สำหรับอุปกรณ์เพิ่มเติม มีแค่บอร์ด arduino กับ LED ที่ติดมากับบอร์ดพอแล้ว อย่างน้อยๆทำให้เรา คุ้นเคยกับไมโครคอนโทรลเลอร์ และ เข้าใจพื้นฐานการเขียนโปรแกรมบน arduino กันครับ


<1> Blinking LED

Blinking LED คือ ไฟกระพริบ การหัดเขียนโปรแกรม เราจะเริ่มต้นทดสอบการเขียนโปรแกรมง่าย ให้ได้ Output ออกมาอย่างรวดเร็ว เหมือนกับ ในทางคอมพิวเตอร์เราจะเขียนโปรแกรม “Hello World”  ให้คอมพิวเตอร์ส่งข้อความออกมาทักทายทางจอภาพให้เร็วที่สุด ก้อเพื่อทดสอบว่าเราเริ่มจะเข้าใจการเขียนโปรแกรมแล้ว เซ็ทคอมไพล์เลอร์ เซ็ทบอร์ดถูกต้อง ผมเชื่อเลยว่ายังมีบางคน ต่อให้ พิมพ์ตาม ก้อยังมีอะไรสักอย่างที่ต้องผิคพลาดแน่ๆ เดี่ยวมาลองดูกัน
ก่อนจะทำไฟกระพริบกัน มารู้สิ่งแรกของการเขียนโปรแกรมบน Arduino ก่อนครับ การเขียนโปรแกรมบน Arduino จะเรียกว่า “sketch” (สะ-เคทช) เพราะว่าจริงๆ มันไม่เห็นรูปแบบการเขียนโปรแกรมแบบมาตราฐานนั้นสิ  มันบอกเรานิดๆว่า โปรแกรมที่เราเขียนเป็นแบบร่างๆ อยู่นะ

โครงสร้างใน sketch

ที่แตกต่างจากรูปแบบมาตราฐานคือ ใน sketch จะมี ฟังก์ชั่นเพิ่มเติมสองส่วน ได้แก่
ฟังก์ชั่น Setup() ทุกครั้งของการทำงาน ตั้งแต่จ่ายไฟ arduino จะทำงานตามคำสั่งที่อยู่ใน setup() เป็นส่วนแรก และ ทุกคำสั่งใน setup() ทำงานแค่ครั้งเดียวเท่านั้น ส่วนนี้จึงตั้งชื่อว่า setup หรือเอาไว้ตั้งค่านี้เอง
?
1
2
3
4
5
Void Setup() {
  // the setup() method runs once ,when starts
  // setup() ทำงาน แค่ครั้งแรก ครั้งเดียว ในใช้ในการ initial ค่าตัวแปร
  ……………………………
}
ฟังก์ชั่น loop() หลังจากที่ทำงานส่วน setup() ,โปรแกรมใน sketch จะทำงานในฟังก์ชั่น loop() ตามชื่อ ตลอดการจ่ายไฟ arduino จะทำงานทุกคำสั่งที่อยู่ใน loop() วนไปเรื่อยๆ
?
1
2
3
4
5
Void Loop(){
   // the loop() method runs again and again ,as long as arduino have a power.
   // loop() หลังจากรันส่วน setup ,โปรแกรมจะทำงาน เฉพาะคำสั่งที่อยู่ใน loop() และ วนอยู่ลูป เท่านั้น
   ……………………………
}

ลงมือกันเลย


อุปกรณ์ที่จำเป็น
วงจร ยังไม่มี ใช้ LED จากบอร์ด Arduino เลย

เกริ่นมากแล้ว เริ่มกันเลยดีกว่าไฟกระพริบ พิมพ์ sketch ตามตัวอย่างข้างล่าง แล้วกดปุ่มคอมไพล์ (อยากให้พิมพ์เองนะครับ 😀 จะได้ชินกับการเขียนโปรแกรม)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Blinking Testing Program
int ledPin =  13;    // LED connected to digital pin 13
 
// The setup() method runs once, when starts
void setup()   {
  // initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}
 
// the loop() method runs again and again
// as long as Arduino has power
void loop()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(1000);                  // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(1000);                  // wait for a second
}
**สำหรับใครที่ compile ไม่ผ่าน มีเรื่องหนึ่งที่ผมไม่ได้บอกไว้ คือ การเขียนโปรแกรมบน Arduino ตัวเล็ก ตัวใหญ่มีผลด้วยนะครับ เรียกว่า“Case Sensitive”
digitalwrite();  , DigitalWrite();  , digitalWRITE();
รูปแบบข้างบน ใช้ไม่ได้ มันผิค ใช้ได้แค่ digitalWrite();
ฉะนั้น ใคร compile ไม่ผ่าน ลองกลับไปดูว่าพิมพ์ ถูกหรือป่าว ถ้าเป็นคำสั่ง และพิมพ์ถูกต้อง  ตัว Arduino IDE  จะเปลี่ยนเป็นตัวเข้มให้เองครับ
** ถ้าใคร upload ไม่ผ่าน กลับไป บทเริ่มต้นใช้งานเลยครับ น่าจะเซ็ทอัป ผิค

Sketch ว่ามันทำงานกันอย่างไง?

สำหรับคนที่คอมไพล์ผ่าน โดยไม่มีปัญหาใดๆ ก็กดอีกปุ่ม upload ได้เลย สิ่งที่เราเห็นว่าไฟกระพริบ ความจริงแล้ว ที่เราเห็นก้อคือ การจ่ายไฟกับ ไม่จ่ายไฟให้ LED พอมันทำแบบ loop() เราจึงเห็นมันติดและดับ เป็นไฟกระพริบอย่างที่เห็น
จากตัวอย่างจะเห็น คำสั่งของ arduino สามคำสั่ง คือ digitalWrite() ,delay() ,pinMode() ซึ่งอยากศึกษารายละเอียด กดปุ่ม Help -> Reference  ที่ Arduino IDE ได้ครับ จะพาไปหน้า อธิบายคำสั่งนี้เอง

เมื่อจ่ายไฟ โปรแกรมจะทำงานในส่วนของ setup() ก่อน โดยเราได้กำหนดว่าจะใช้ขาไหนว่าเป็น Output เพื่อจ่ายไฟให้ LED ไว้โดยใช้คำสั่ง pinMode()  โดยที่ขา LED บนบอร์ด Arduino จะต่อกับ D13 ครับ จากตัวอย่างเราจึงสร้างตัวแปรชื่อ ledPin ซึ่งมีค่า 13 ไว้ เพื่อใช้แทนกำหนด ตัวเลข 13 ลงไปในโปรแกรม
?
1
2
3
4
5
6
7
int ledPin =  13;   // LED connected to digital pin 13
 
// The setup() method runs once, when the sketch starts
void setup()   {
  // initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}
มาถึงฟังก์ชั่น Loop() เราได้ใส่คำสั่ง digitalWrite() เป็นคำสั่งให้ขา Digital ของ Arduino จ่ายไฟ หรือ หยุดจ่ายไฟ คิดง่ายๆว่า Arduino เหมือนสวิตส์ที่เราสั่งเปิดปิดไฟ ได้โดยการโปรแกรมคำสั่ง การสร้างไฟกระพริบ ก้อเป็นการจ่ายไฟ และ หยุดจ่ายไฟ ที่เป็นจังหวะเท่ากัน  ดูในคำสั่งข้างล่าง ผมใส่ digitalWrite() แล้วจะต่อท้าย delay() เพื่อให้ไฟติด และหน่วงเวลาไว้ เพื่อให้มันยังติดหรือดับอยู่
?
1
2
3
4
5
6
7
8
// the loop() method runs over and over again, as long as Arduino has power
void loop()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(500);                   // wait for a second
  digitalWrite(ledPin,LOW);     // set the LED off
  delay(500);                   // wait for a second
}
เอาล่ะครับ ตอนนี้เราได้ไฟกระพริบ แบบยังไม่รู้เลยวงจรอย่างไง 😀 เอาเป็นว่า เดี่่ยวรอบหน้าจะให้ลองลงมือมากขึ้นนะครับ สำหรับตอนนี้เราก้ออุ่นใจ เราว่าเขียนโปรแกรมบน Arduino ได้ และ บอร์ดที่เราได้มาไม่มีปัญหา  มาเจอความความท้าทายอันต่อไป
แบบทดสอบย่อย เพิ่มเติมไปลองทำดูเองนะครับ
สำหรับ ใครมีอุปกรณ์เพิ่มเติม ลองหา LED มาเพิ่ม ถ้าเราอยากจะย้าย จาก LED ที่ต่อกับ digital pin 13 (D13) มาใช้ขา digital pin 12 (D12) จะต้องทำอย่างไง
ทำได้ ส่ง เมล์ ส่ง BB มาบอกผม ด้วยนะ

<2> Too Fast ,Too Slow (Blinky LED II)

จากแบบฝึกหัดที่แล้ว ง่ายๆมาก ใช้ไฟกระพริบเดิมนี้ล่ะครับ เราจะทำอย่างไงให้ ไฟมันกระพริบ ช้าหรือเร็วขึ้น จากแบบฝึกหัด ครั้งที่แล้ว เราจะเห็นว่าการกระพริบของ LED คือ การติดหรือดับ LED เป็นจังหวะโดยกำหนดค่าหน่วงเวลาไว้
ฉะนั้น ถ้าเราอยากให้มันกระพริบเร็วหรือช้า ก้อแค่เปลี่ยนค่าหน่วงเวลา ใน delay() ครับ ลองแก้ไข sketch เดิมเป็น sketch ใหม่ ตามข้างตารางข้างล่างครับ
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int ledPin =  13;    // LED connected to digital pin 13
 
// The setup() method runs once, when the sketch starts
 
void setup()   {
  // initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}
 
// the loop() method runs over and over again,
// as long as Arduino has power
 
void loop()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(250);                   // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(250);                   // wait for a second
}
จากตัวอย่างข้างต้น จะทำให้ไฟกระพริบถี่ขึ้น ถ้าเราอยากให้เร็วขึ้นอีกล่ะ เราก้อลดค่าใน delay() ลงไปอีก ลองแก้ไข คำสั่งในฟังก์ชั่น loop() จากตัวอย่างข้างต้น เป็นค่าใหม่ดังตารางข้างล่างครับ
?
1
2
3
4
5
6
7
void loop()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(100);                   // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(100);                   // wait for a second
}
รอบนี้ ลองอีกเพิ่มเวลา เพื่อให้ ไฟกระพริบช้าลงได้
?
1
2
3
4
5
6
7
void loop()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(1000);                  // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(1000);                  // wait for a second
}
ถ้าใครยังสนุกอยู่ ลองเปลี่ยนค่าหน่วงเวลาเล่นดูครับ ดูสิว่า เราทำค่ามากสุด น้อยสุด จะทำให้เกิดอะไรขึ้น หรือ ลองทำไฟกระพริบ เป็นจังหวะอื่นบ้าง อย่างจังหวะเต้นหัวใจ มาถึงตอนนี้ เราคงจะได้เห็นว่า แค่เปลี่ยนโปรแกรม ทำให้ Hardware ทำงานได้ไม่เหมือนเดิมแล้ว

<3 >สร้างฟังก์ชั่นกันดีกว่า

มาลองสร้างฟังก์ชั่นกันบ้าง สำหรับตอนที่ ผมหัดเขียนโปรแกรมใหม่ ผมก้อสงสัยว่าเราจะสร้างฟังก์ชั่นกันไปทำไม เอาเป็นว่า ถ้าเราอยากปรับเปลี่ยนการหน่วงเวลา หรือ ใช้ทำไฟกระพริบบ่ิอยๆ
จะให้ก๊อปปี้ โปรแกรมดังกล่าว ไปแปะๆ วางๆ มันก้อดูแปลก ๆจริงไหมครับ
?
1
2
3
4
5
6
// ไฟกระพริบ เทพ ๆ
digitalWrite( ledPin, HIGH );   // set the   LED on
delay(500);                        // wait for a second
 
digitalWrite( ledPin, LOW );   // set the   LED off
delay(500);                       // wait for a second
เขาจึงใช้ฟังก์ชั่นเข้าช่วย ให้การออกแบบโปรแกรม ดูดี เข้าใจง่าย ดูสะอาด ฟังก์ชั่นใช้งานซ้ำๆ ได้ง่ายอีกด้วย
มาดูตัวอย่าง ผมได้สร้างฟังก์ชั่น หรือ ชุดคำสั่ง ขึ้นมาเองได้ ในตัวอย่างนี้ ผมย้ายโปรแกรม”ไฟกระพริบ” มาสร้างเป็นฟังก์ชั่น Blinky() จากตัวอย่างจะเห็นว่า ต่อไปถ้าอยากได้ ไฟกระพริบ 1 ครั้ง เราก้อมักฟังก์ชั่น Blinky() แทนการกระพริบ LED ครับ แต่ถ้าจะให้กระพริบตลอด ก้อเอาฟังก์ชั่น Blinky() ไปใส่ใน Loop() เราจะได้เห็นไฟกระพริบตลอดกาลแล้วครับ ลองทำตาม Sketch ดังตารางข้างล่างดูครับ
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int ledPin =  13;    // LED connected to digital pin 13
 
// The setup() method runs once, when the sketch starts
 
void setup()   {
  // initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}
 
// the loop() method runs over and over again,
// as long as the Arduino has power
void loop()
{
    Blinky();
}
 
void Blinky()
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(500);                  // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(500);                  // wait for a second
}
จะเห็นว่า มันก้อทำงานไฟกระพริบได้เหมือนเดิม แต่เราไม่ต้อง แปะคำสั่งเยอะๆ แต่ว่าที่เห็นมันยังไม่ใช่ความสามารถของฟังก์ชันที่แท้จริงครับ มาดูกันต่อ ฟังก์ชั่นนอกใช้ลดคำสั่งซ้ำๆแล้ว เรายังสามารถส่งค่าตัวแปรผ่านฟังก์ชั่นได้อีกด้วย อย่างเช่นว่า เราอยากจะทำให้ไฟกระพริบ เร็วหรือ ช้าลง เหมือนแบบฝึกหัดที่ 2 แทนที่จะต้องทำฟังก์ชั่น สองตัว เราก้อใช้แค่ฟังก์ชั่นเดียวล่ะครับ ส่งค่าตัวแปรแทน ทำได้ ดังตารางข้างล่างครับ
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int ledPin =  13;    // LED connected to digital pin 13
 
// The setup() method runs once, when the sketch starts
void setup()   {
  // initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}
 
// the loop() method runs over and over again,
void loop()
{
    Blinky(1000);
 
    Blinky(250);
}
 
void Blinky(int time)
{
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(time);                  // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(time);                  // wait for a second
}
จาก Sketch ข้างต้น เราจะทำไฟกระพริบ ช้าๆ และ เร็วๆ สลับกัน อย่างสบายมาก และ sketch ที่สร้างดูดี และเรายังแก้ไขได้ง่ายยิ่งขึ้น อีกด้วยครับ แค่แก้ไข คำสั่งตัวแปรที่ส่งไปกับ Blinky() เท่านั้นเอง
ความสามารถของฟังก์ชั่น ยังมีอีกครับ คือส่งค่ากลับได้อีกด้วย เดี่ยวไว้ทดลองกันในการทดลองหน้าครับ
มาถึงตอนนี้ ความสามารถควบคุม LED เราคงเพิ่มขึ้นเป็นทวีคูณแล้ว ถ้าน้องๆ เพื่อนๆ ทำมาถึงตรงนี้ ผมก้อขอบอกว่า ตอนนี้เราได้ข้ามส่วนที่ยากมาได้แล้ว และ เริ่มเข้าใจ concept การใช้งานไมโครคอนโทรลเลอร์แล้วครับ
สำหรับส่วนที่เหลือจะเพิ่มเติม  เทคนิคการเขียนโปรแกรม พวกส่วนเงื่อนไข และ ส่วน loop-control และ รู้จัก hardware เพิ่มเติมอย่างanalog(Analog to Digital Converter) , Pulse Width Modulation , Serial ครับ พบกันใหม่ตอนหน้า
นาย สุธรรม แสงทรง ปวส.2 เทคโนโลยีคอมพิวเตอร์ เลขที่ 12


อ้างอิง




http://www.ayarafun.com/2011/01/tutorial-arduino-play-with-blinky-led/












เขียนโดย



ที่







































ไม่มีความคิดเห็น:















แสดงความคิดเห็น


















        

      









สมัครสมาชิก:
ส่งความคิดเห็น (Atom)