Ayarafun Factory » Arduino-Tutorial

[Sciguy14] Arduino Tutorial 11: SD Cards and Datalogging

chang — Thu, 05 May 2011 02:53:42 +0000

มาแล้วครับ Tutorial อันที่ 11 รอบนี้ เป็นคิวของ sd-card ครับ สำหรับคนที่กำลังตามหา datalogger อยู่ ผมบอกได้ว่า arduino นิ ทำ datalogger ง่ายมากๆ เพราะว่าภายใน arduino มันมี libary มาแล้ว และรับรองโดยตัว website เขาเองสักด้วย ถ้ามีคนทำเป็นชุดสำเร็จได้ นี้น่าจะดี

สำหรับใครที่มองหาวิธีอยู่ ลองดูวีดีโอนี้ก่อนครับ ผมว่าจะช่วยให้เห็นว่าใช้ arduino ไปบันทึกข้อมูลจาก sd-card ได้อย่างไง และเอาข้อมูลไปใช้งานได้อย่างไง

โอเคครับ สำหรับวันว่างนี้ ลองเอาไปเล่นกันดูครับ เดี่ยวทางผมจะเอาลองเลยเล่น แล้วจะมาเล่าให้ฟังอีกรอบครับ

http://www.youtube.com/watch?v=5v5A3j7Rrco

สำหรับใครที่ติดตาม วีดีโอ Arduino Tutorial จากทางเวปไอยาราฟันส์นะครับ ผมได้รวบรวมโดยกด TAG “SCIGUY14″ หรือเข้าไปดูที่ Youtube Channel ของทางเขาได้ครับ

No related posts.

Arduino Tutorial 3 : Digital input ,Debounce

chang — Tue, 26 Apr 2011 17:44:42 +0000

สำหรับในตอนนี้ ผมจะเพิ่มเติมวงจรอิเล็กทรอนิกส์ลงไปบ้างครับ การเขียนโปรแกรมไมโครคอนโทรลเลอร์ มันจะต่างจากการเขียนโปรแกรมบนคอมพิวเตอร์ ตรงส่วนนี้ล่ะครับ คือเราจะได้เรียนรู้เรื่อง hardware อิเล็กทรอนิกส์ด้วยครับ ในโลกไมโครอิเล็กทรอนิกส์ เป็นการเรียนรู้ ไม่รู้จบจริง มันจะมีเทคโนโลยีใหม่ มาให้เราต้องไปเรียนรู้เรื่อยๆ (อยู่ใช้มาหลายปี ผมบอกได้ว่าตามได้ ไม่หมดครับ แต่สนุก)

วันนี้เราจะพาเพื่อนชาวเวป นำไมโครคอนโทรลเลอร์ไปใช้งานกับ ปุ่มกดกันนะครับ สำหรับปุ่มหรือสวิตซ์ เป็นสิ่งที่คุ้นเคยกันดี ในอุปกรณ์อิเล็กทรอนิกส์ที่เห็น อย่างเช่น มือถือเราก็มีปุ่ม ตู้ ATM ก็มีปุ่มหรือสวิตซ์ ซึ่งก็ถือว่าสวิตซ์เป็นเรื่องพื้นฐานมากๆ การสร้างเครื่องมือทางอิเล็กทรอนิกส์ครับ ได้ใช้งานแน่ๆ

สวิตซ์ คือ อุปกรณ์ที่ ตัด-ต่อ ไฟฟ้า เข้าถึงกัน เหมือนเป็นสะพานครับ ยกขึ้น ไฟไหลผ่านไม่ได้ แต่เหมือนกดลงไฟไหลผ่านได้ ซึ่งมีหลายแบบ ไม่ว่าแบบกด แบบโยก มาดูตัวอย่างสวิตซ์ ที่ใช้กันบ่อยๆ นะครับ

Button หรือปุ่มกดแบบโรงงาน มันจะมีขนาดใหญ่ และ ทนทานมาก
Tact switch เป็นปุ่มกด พบได้บนแผงวงจรอิเล็กทรอนิกส์ บนบอร์ด arduino จะมีเป็นปุ่มสำหรับ Reset
Micro Switch หรือ บางที่เรียกว่า Limit Switch อันนี้จะเห็นมากที่ใช้ในเครื่องจักร

และ ยังมี อุปกรณ์อื่นๆ ที่ทำงานเหมือนเป็นสวิตซ์ ได้อีกด้วย เช่น

Mercury Switch หรือบางที่เรียกสวิตซ์ปรอท จะใช้ปรอทเป็นตัวนำไฟฟ้า สำหรับสวิตซ์แบบนี้ ถูกประยุกต์ไปใช้ตรวจสอบความเอียงได้ครับ คือเอียงมายังตำแหน่ง ปรอทไหลไปชนขั้วไฟฟ้าให้เชื่อมติดกัน ทำให้ไฟฟ้าไหลผ่านได้
Reed Switch ตัวนี้จะเป็นสวิตซ์แม่เหล็ก คือใช้หลักการง่ายๆ ถ้า Switch นี้อยู่ใกล้แม่เหล็ก ขั้วเหล็กจะติดกัน เห็นในประตูหรืออุปกรณ์กันขโมยใช้บ่อยๆ
เรายังดัดแปลง อุปกรณ์หลายๆอย่างที่ทำงาน อย่างเช่นว่าเราสามารถใช้เหรียญบาท มาดัดแปลงเป็น สวิตซ์หาความเอียง ได้ครับ

เอาสวิตซ์ไปใช้งานได้อย่างไง

สิ่งแรกที่เราต้องทำความเข้าใจ เราจะแบ่งสถานะทางดิจิตอล ได้เพียงสองสถานะ คือ High หรือ Low หรือ ON – OFF , หรือ บางที่จะเรียกสัญญาณทาง ดิจิตอลว่า “0” กับ “1”
ในทางกายภาพแล้ว เราจะแบ่งสถานะทางดิจิตอล ด้วยแรงดันไฟ
สำหรับ Arduino จะใช้แรงดัน คือ “HIGH” คือ ไฟระดับ 5 Volt และ “LOW” คือ ไฟระดับ 0 Volt
ดังนั้น สิ่งที่เราต้องทำ คือ เปลี่ยนการกดสวิตซ์ ให้เป็นการเปลี่ยนแรงดันสักก่อน

วงจร Pull-up ,Pull-down

สถานะที่กำหนดให้ขาของอุปกรณ์อิเล็กทรอนิกส์ รอรับอินพุท (INPUT) ขาพอร์ตจะเป็น High Impedance คือมีความต้านทานสูงมากต่ออยู่ ทำให้ขาพอร์ตนั้น เสมือนถูกปล่อยลอย ค่าอินพุทที่อ่านกลับมาได้ มันไม่แน่นอน

ดังนั้นในงานขาพอร์ตอินพุท วงจรของสวิตซ์ จำเป็นมากที่ต้องมี Pull-up Resistor หรือ Pull-down Resistor เพื่อที่จะกำหนดสภาวะดิจิตอลที่แน่นอน ให้กับอุปกรณ์อิเล็กทรอนิกส์ (ไม่ได้ เฉพาะเจาะจงว่าเป็นแค่ arduino นะครับ ทุกอุปกรณ์อิเล็กทรอนิกส์เลยที่บอกว่าขาอินพุทเป็น High Impedance)

ตามปกติ ตัวต้านทานที่ใช้ในวงจร Pull-up หรือ Pull-down จะใช้ประมาณ 5k Ohm -20k Ohm

Pull-up Resistor คือการนำตัวต้านทานต่อเข้ากับ Vcc (+5V) เพื่อให้แรงดันอยู่คงที่ ทำให้อยู่ในสถานะ “HIGH” หรือ “1” ตลอดเวลา และเมื่อกดสวิตซ์ กระแสไฟฟ้าจะไหลลง Ground ทันที ซึ่งทำให้สถานะเป็นลอจิก “LOW” หรือ “0” และ การทำงานลักษณะนี้ จะเรียกว่า Active Low เพราะว่าจะเขียนโปรแกรมที่ทำงาน เมื่อลอจิกเป็น “LOW” ส่วนใหญ่ เราจะเห็นต่อสวิตซ์ นิยมใช้แบบ Pull-up มากกว่า

Pull-down Resistor โดยใน Pull-down จะมีลักษณะคล้ายกับ Pull-up Resistor แตกต่าง ตรงที่ สภาวะปกติของ Pull-down จะเป็นลอจิก “LOW” หรือ “0” เมื่อมีการกดปุ่ม กระแสไฟจะไหลเข้าขาอินพุท ทำให้ ลอจิกเป็น “HIGH” หรือ “1″ ได้ การทำงานในลักษณะนี้ จะเรียกว่า Active High

ทำการทดลองกันครับ

สวิตซ์เบื้องต้น

Sketch แรกสำหรับตอนนี้ เราจะลองทำสวิตซ์ไฟแบบ กดติดปล่อยดับ ง่ายก่อน โดยวงจรสวิตซ์ เราจะต่อแบบ Pull Up resistor เอาไว้ ดังรูป

โดยวงจรที่ใช้ จะมีการ Pull-Up ตัวต้านทาน เอาไว้ ระดับแรงดัน ในสภาวะปกติ จะอยู่ที่ 5 โวลต์ หรือ ลอจิก “1” แต่ถ้ามีการกดปุ่ม แรงดันจะอยู่ที่ 0 โวลต์ หรือ ลอจิก “0” หรือ เรียกว่า active Low ครับ

เราสามารถจากสถานะการกดสวิตซ์นี้ เราสามารถเอาไปทำโปรแกรม ได้ดังตัวอย่างนี้ครับ

int buttonPin = 2;
int ledPin =  13;
boolean buttonState = 0;

void setup() {
      pinMode(ledPin, OUTPUT);
      pinMode(buttonPin, INPUT);
}

void loop()
      buttonState = digitalRead(buttonPin);

      if (buttonState == HIGH) {
         digitalWrite(ledPin, LOW);
      } else {
         digitalWrite(ledPin, HIGH);
      }
}

ตามตัวอย่าง ผมได้เขียน การปกติเมื่อไม่มี การกดปุ่ม ไฟ LED จะไม่สว่าง แต่ถ้ามีการปุ่มกด LED จะติดขึ้นครับ แต่เมื่อปล่อยมันก็ดับ

เราต้องกำหนดขาพอร์ต buttonPin ให้เป็น อินพุท (INPUT) ด้วย (ตามปกติ ตอนเริ่มต้น ถ้าไม่มีการกำหนดใดๆ ในโปรแกรม บอร์ด Arduino จะกำหนดให้ทุกขา อินพุท(INPUT) อยู่แล้ว เราจะใส่หรือไม่ใส่คำสั่งนี้ก็ได้ครับ)

โดยใช้คำสั่ง pinMode ();

[1]

pinMode(pin)

ปกติพอร์ตจะถูกกำหนดให้เป็น INPUT อ่านค่าสถานะ จาก pin ส่งค่ากลับมาเป็น HIGH หรือ LOW

การอ่านสถานะดิจิตอล จะใช้คำสั่ง

[ 2]

int digitalRead(pin)

อ่านค่าสถานะ จาก pin ส่งค่ากลับมาเป็น HIGH หรือ LOW

คำสั่ง digitalRead จะส่งค่ากลับมาครับ (หรือเรียกว่า จะ Return ค่ากลับมา) เวลาใช้งานเราก้อควรจะสร้างตัวแปร ไว้รับค่าด้วย ตามตัวอย่าง ผมจะสร้าง ตัวแปรชื่อ buttonState ไว้รับค่า(return)

buttonState = digitalRead(buttonPin);

เราจะได้สถานะการกดหรือปล่อย สวิตซ์มาแล้วอยู่ใน ตัวแปร buttonState ซึ่งในคราวนี้ก้ออยู่ที่ว่าเราสถานะนี้เอาทำงานอะไรต่อไป

สวิตซ์ควมคุมความเร็วไฟกระพริบ

หลายคนคงคิดถึงวงจรไฟกระพริบ รอบนี้ผมเลยเอาตัวอย่างไฟกระพริบมาประยุกต์ เพิ่มเติมกับสวิตซ์ ในครั้งนี้ เราจะเอาค่าสถานะการกด-ปล่อย มาใช้ในควบคุมความเร็วของไฟกระพริบ กดปุ่มจะกระพริบเร็วขึ้น ปล่อยจะกระพริบด้วยความเร็วปกติ สำหรับวงจร เราใช้ต่อเนื่องจากแล๊ปทดลองที่ 7 ต่อได้เลยครับ

int ledPin =  13;
int buttonPin = 2;

boolean buttonState;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
}

void loop() {
  int timeDelay;
  buttonState = digitalRead(buttonPin);

  if (buttonState == HIGH)  {
      timeDelay =1000;
   }  else  {
      timeDelay = 100;
   }
   blinky(timeDelay);

}

void Blinky(int time) {
   digitalWrite(ledPin ,HIGH);
   delay(time);
   digitalWrite(ledPin ,LOW);
   delay(time);
}

จากเห็นว่าโครงสร้างโปรแกรมจะคล้ายกับแล๊ป 7 นะครับ คืออ่านค่าสถานะสวิตซ์กลับมา แต่ในรอบนี้เราเอาสถานะสวิตซ์ไป เปลี่ยนค่าเวลาที่ใช้ delay ในโปรแกรมไฟกระพริบครับ หวังว่าจะเห็นภาพการอ่านค่าสถานะของการกดสวิตซ์ไปใช้งานกันแล้วนะครับ

Toggle Switch

มาลองทำสวิตซ์แบบขั้นสูง (Advance) กันบ้าง สำหรับสวิตซ์ที่จะทำเป็นแบบ Toggle ครับ คือ กดติด กดดับ การทำงานคือกดหนึ่งครั้ง ไฟ LED จะติด และพอปล่อย ไฟจะยังไม่ดับ ยังติดต่อไป แต่ถ้าเรากดปุ่มอีกครั้ง ไฟจะดับ และก็ยังดับต่อไป

Toggle เป็นสวิตซ์ที่จำค่าสถานะการกด ไว้นะครับ กดหนึ่งครั้งเปลี่ยนจากดับเป็นติด และ กดอีกหนึ่งครั้งจะเปลี่ยนจากติดเป็นดับ วิธีการเขียนตามตัวอย่างเลย

int ledPin = 13;
int buttonPin = 2;

boolean buttonState;
boolean lastState;
boolean state = HIGH;

void setup() {
  pinMode (buttonPin,INPUT);
  pinMode (ledPin,OUTPUT);
}

void loop() {
  buttonState = digitalRead(buttonPin);

  if ( ( buttonState == LOW) && (lastState == HIGH) ) state = !state;

  digitalWrite(ledPin,state);

  lastState = buttonState;
 }

เห็นว่า Sketch ไม่ได้ Advance อะไรมากครับ เพียงแค่เปลี่ยนจากการกดแล้วเอาไปเปิด-ปิด ไฟ LED เอาไป เก็บค่าสถานะ ของหลอดไฟ

โดยใน Sketch นี้ ผมจะสร้างตัวแปรที่ชื่อ state เพิ่มมาอีกหนึ่งตัว เมื่อใดที่มีการกดปุ่ม state จะถูกกลับเป็น state ตรงข้าม จาก High เปลี่ยนเป็น Low หรือ จาก Low เปลี่ยนเป็น High โดยคำสั่ง

state = !state;

และเก็บค่า buttonState สุดท้ายไว้ใน lastState ด้วย เพื่อใช้ในการตรวจสอบว่า ค่าที่เกิดจากการกดในรอบนี้ ที่เป็นสัญญาณลอจิก “LOW” เกิดจากสภาวะครั้งที่แล้ว ที่ยังไม่มีการกดปุ่ม สถานะจะเป็น “HIGH” อย่างแน่นอน เพื่อให้อ่านค่าการกดปุ่มเพียงครั้งเดียวครับ

หลังจากที่ upload sketch เข้าไปทดลอง จะเห็นว่า เราสามารถทำสวิตซ์แบบ toggle ได้แล้ว คือกดติด กดดับ

แต่ช้าก่อนนะครับ หลังจากทดลองจะเห็นว่า มันไม่ได้ทำงานเหมือน sketch ที่เราเขียนเลย หรือเราว่าเขียนโปรแกรมผิค

ความจริงการทำงานโค๊ดนี้ เขียนถูกต้องครับ แต่เกิดสิ่งที่เราไม่ได้คาดไว้คือ สวิตซ์ทุกชนิด ที่มีหน้าสัมผัส (contact) เป็นโลหะ มักจะมีปัญหาการ bounce ของสัญญาณ คืออาการไกว่ของสัญญาณ ซึ่งจะเกิดในสั้นๆ 5-50 นาโนวินาที สาเหตุหนึ่งที่ทำให้เกิด ในช่วงที่กดปุ่ม หน้า contact จะสัมผัสไม่แนบสนิท จะเกิดสัญญาณ bounce คืออาการที่สัญญาณจะสลับ เป็น High หรือ Low อย่างรวดเร็ว สังเกตจากกราฟ ก่อนที่จะเข้าสู่สภาวะเสถียร

sketch นี้จึงทำงานเห็น กดติดบ้าง ไม่ติดบ้าง เนื่องจากไม่ได้ เขียนส่วนป้องกันการ bounce ไว้ จะเห็นได้ว่าการเขียนโปรแกรมบนไมโครฯ จะไม่เหมือนเขียนใช้งานคอมพิวเตอร์ ในส่วนนี้ล่ะครับ เพราะว่าจะมีส่วนของ Hardware มาเกี่ยวข้องด้วย

Toggle Switch แบบปรับปรุง

เรามาหา วิธีการแก้ปัญหา bounce ของสัญญาณกันดีกว่า สำหรับ อาการ bounce คือการที่สัญญาณยังไม่นิ่ง เกิดการเหวี่ยงในช่วงสั่นๆ ระยะเวลาการเกิด 5-50 นาโนวินาที และ เกิดช่วงเริ่มต้นของการกดสวิตซ์

วิธีการแก้ไขที่ง่ายที่สุด คือ หลังจากหน้า contact หรือกดปุ่มในครั้งแรก arduino จะรับสัญญาณการกดปุ่มได้ แต่มันยังไม่แน่ใจว่า สวิตซ์โดนกดจริงหรือป่าว ให้รออีกสัก 5-50 นาโนวินาที แล้วตรวจสอบสถานะการกดปุ่มอีกรอบ ถ้ามีการกดจริง สัญญาณดิจิตอลที่อ่านได้ อยู่ในช่วงที่เสถียร ซึ่งค่าที่ออกมาจะบอกได้ว่ากด แต่ถ้าตรวจสอบอีกที่แล้วไม่พบ แสดงว่าสัญญาณที่ได้รับ เป็น noise ในระบบ ดังนั้น sketch ใหม่ จึงได้ดังนี้

int ledPin = 13;
int buttonPin = 2;

boolean buttonState;
boolean lastState;
boolean state = HIGH;

 void setup() {
  pinMode (buttonPin,INPUT);
  pinMode (ledPin,OUTPUT);
}

void loop() {
  reading = digitalRead(buttonPin);

  if ( reading == LOW && lastState == HIGH ) {
    delay (10);
    if (digitalRead(buttonPin) == LOW) state = !state;
  }

  digitalWrite(ledPin,state);
  lastState = reading;

}

เห็นว่า เมื่อเราเข้าใจปัญหา เราจะเขียนโปรแกรมได้แก้ง่ายมากๆ ผมน่าจะบอกตั้งแต่แรก ฮ่าๆ ผมเป็นพวกชอบแกล้งคนครับ ให้โดนเยอะๆ จะได้เอาไปโม้เพื่อนๆ ต่อได้
สำหรับรอบนี้ ก็คงพอจะเข้าใจวิธีการใช้ไมโคร และใช้งาน arduino เพิ่มขึ้นอีกนิดแล้ว ก็มีปัญหาไม่เข้าใจส่วนไหน ติชม หรือ comment เข้ามาได้นะครับ เจอกันโอกาสหน้า บายยย ^_^

No related posts.

[Sciguy14] Arduino Tutorial 10: Interrupts and Hardware Debouncing

chang — Sat, 23 Apr 2011 04:44:29 +0000

วีดีโอ Tutorial ตัวใหม่มาอีกแล้วครับ รอบนี้ Jeremy Blum สอนให้ใช้งาน Interupts ซึ่งเป็นเรื่องที่เข้าใจยาก อย่างหนึ่งในการเขียนโปรแกรมไมโครฯ ครับ แต่สำหรับ Arduino ทำให้เรื่องนี้ดูง่ายมาก ใครตามมาถึง 10 ตอนแล้ว ผมว่า การใช้ Arduino น่าจะเป็นเรื่องสนุกกันแล้วใช่ไหมครับ

http://www.youtube.com/watch?v=CRJUdf5TTQQ

Interrupts – An extremely useful, yet often feared element of microprocessors. Interrupts allow you run a program, while still being able to react to asynchronous input from the outside world. On many platforms then can be confusing to implement, but the arduino makes it easy! In this week’s episode, I’ll show you how to use a hardware-debounced button to activate a hardware interrupt on the arduino. I’d suggest you go check out episode 2, where I initially introduced button debouncing, if you haven’t already. I won’t be covering timer interrupts in this episode, since I recently wrote an extensive blog post about using them. Enjoy the video!

No related posts.

[Sciguy14] Arduino Tutorial 08: SPI Interfaces

chang — Sun, 06 Mar 2011 13:00:09 +0000

วีดีโอสอนการใช้ SPI Bus ,คราวนี้อุปกรณ์อิเล็กทรอนิกส์หลายๆตัวที่เป็น SPI เราจะได้ต่อใช้งานได้แล้ว สำหรับวีดีโอนี้เขาจะสอนใช้ Analog Devices 5204 Digital Potentiometer
เอามาควบคุมความสว่างของ LED (ไม่รู้จะเบื่อ LED กันไปหรือยังนะครับ) สำหรับไอซี จะไม่มีในไทยครับ ดูเอาหลักการ กันไปก่อนแล้วกันครับ

No related posts.

[Sciguy14] Arduino Tutorial 07: I2C Communication and Processing

chang — Tue, 22 Feb 2011 06:25:27 +0000

วีดีโออันต่อไปครับ สำหรับหัดใช้ arduino มาถึงตอนที่ 7 สำหรับตอนนี้จะเกี่ยวกับ I2C ครับ เป็นการสื่อสารระหว่างไอซี ความเร็วสูงกว่า serial ครับ สำหรับอุปกรณ์ในตัวอย่าง จะเป็นเซ็นเซอร์วัดอุณหภูมิ อาจจะหายากสักนิดนะครับ ก้อดูเป็นแนวทางแล้วกันครับ

No related posts.

[Sciguy14] Arduino Tutorial 6: Serial Comm and Processing

chang — Wed, 16 Feb 2011 02:24:11 +0000

อีกสักรอบ รอบที่แล้วที่ผมลองในเวป อาจจะดูไม่เข้าถึง รอบนี้มาดู sciguy14 ใช้ arduino กับการสื่อสารด้วย serial อีกสักรอบ ในตอนนี้จะมีตัวอย่างการใช้งาน arduino สื่อสารกับคอมพิวเตอร์ โดยใช้ serial ครับ และจะมีตัวอย่างลองใช้โปรแกรม processing ควบคุมอุปกรณ์อีกด้วย ผมว่าถ้าไมโครไม่ต้องหรูมาก ต่อกับคอมได้ สามารถทำโปรแกรมสร้างสรรค์ได้เยอะแยะแล้ว

No related posts.

[Sciguy14]Arduino Tutorial 5: Motors and Transistors

chang — Tue, 08 Feb 2011 17:42:35 +0000

รวดเร็วมากๆ ตานาย JeremyBlum มีบทเรียนเพิ่มอีกแล้ว สำหรับตอนนี้จะเป็นวิธีการ ใช้งานมอเตอร์ DC ตัวเล็กๆ กับ ทรานซิสเตอร์ และ ต่อท้ายด้วย RC-Servo ด้วยครับ สำหรับ tutorial ของนาย JeremyBlum ผมว่าเขาทำดีมาก ให้ดูวิธีการอธิบายวงจร กับวิธีการสอนการเขียนโปรแกรมครับ ผมว่าน่าจะเข้าใจได้ไม่ยากครับ

First up, we’ll control a standard DC motor running off a 9V battery with the help of an NPN transistor and a PWM (Pulse Width Modulated) signal from the Arduino. Next, it’s onto 180 degree servo motors, which we will power on an independent 5V rail using a voltage regulator. We’ll control the servo using a PWM signal from the arduino, and I’ll show you how you can turn analog distance readings into precise angles for the servo to turn to!

No related posts.

Arduino Tutorial 2 : สื่อสารด้วย Serial

chang — Mon, 31 Jan 2011 20:00:59 +0000

มารอบนี้ ขอเริ่มด้วยพูดเรื่องการสื่อสารระหว่างคอมพิวเตอร์กับ arduino กันบ้าง ที่ทางผมเอาเรื่องนี้มาพูดก่อน เพราะว่าการข้อความ หรือ Text message มันนำจะทำให้ไมโครส่งค่าภายในออกมาแสดงผลได้ เข้าใจง่าย และการสื่อสารจะเป็นการสื่อสารสองทาง จะส่งจาก arduino ไปยังคอมพิวเตอร์ หรือ จะส่งจากคอมพิวตอร์ เข้าไปสั่งงาน arduino ก้อทำได้ครับ

สำหรับในไมโครคอนโทรลเลอร์ เรายังใช้ Serial ในการเชื่อมต่ออุปกรณ์อื่นอีกด้วย ไม่ว่าจะเป็นข้อมูลพิกัดอย่าง GPS ,อ่านบัตร RFID และอุปกรณ์ออกแบบเฉพาะงานอย่างเช่น Serial LCD character สำหรับแสดงผล และ Serial Servo Control สำหรับงานควบคุมมอเตอร์ servo จำนวนมากๆ

ดังนั้นในตอนที่สอง เราจึงมาให้เริ่มใช้งานพื้นฐานของการสื่อสารกันครับ สำหรับการสื่อสารภายนอก arduino จะใช้พอร์ตที่เรียกว่า Serial หรือ ภาษาไทยเรียกพอร์ตอนุกรม แต่ผมขอเรียกทับศัพท์แล้วกันนะครับ มันไม่คุ้น พอร์ต Serial มันเป็นพอร์ตการสื่อสารที่เป็นมาตราฐาน ที่ใช้กันมาตั้งแต่เมาส์ และ คียบอร์ด

การสื่อสารแบบอนุกรม หรือ Serial เป็นส่งข้อมูล โดยใช้เทคนิคการเลื่อนข้อมูล (Shift Bit) ส่งไปที่ล่ะบิต บนสายสัญญาณเส้นเดียว โดยการส่งข้อมูลแบบ Serial จะไม่มีการ sync สัญญาณนาฬิการะหว่างตัวรับและตัวส่ง แต่จะอาศัยวิธีตั้งค่าความเร็วในการรับส่งสัญญาณให้เท่ากั น หรือ เรียกว่าตั้งค่า baud rate และส่งสัญญาณ start และ stop เพื่อบอกว่า เป็นส่วนต้นของข้อมูล (start bit) หรือ ส่วนท้ายของข้อมูล (stop bit) ดังรูป

รูปแบบของ ข้อมูลจากที่ส่งผ่าน Serial จะมีการเพิ่ม Start bit และ Stop bit เข้าไปเพิ่มจากข้อมูลเดิม

บิตเริ่มต้น (Start bit) จะมีขนาด 1 บิต จะเป็นลอจิก LOW
บิตข้อมูล (Data bit) 8 บิต ข้อมูลที่จะส่ง
บิตภาวะคู่หรือคี่ (Parity bit) มีขนาด 1 บิต ใช้ตรวจสอบข้อมูล ถ้าข้อมูลที่ได้รับไม่สมบูรณ์ นำเข้าค่ามา check กับ Parity bit จะได้ค่าไม่ตรงกัน
บิตหยุด (Stop bit) เป็นการระบุถึงขอบเขตของการสิ้นสุดข้อมูล จะเป็นลอจิก HIGH

เอาล่ะครับ ผมเล่าเรื่องทฤษฏี ไม่รู้หลับไปหรือยังที่กล่าวมา ก้อเพื่อให้เข้าใจหลักการเบื้องต้นครับ สำหรับการสื่อสารกับคอมพิวเตอร์ Arduino จะมีโมดุล hardware และมี library ภายใน ที่จัดการเรื่อง Serial อยู่แล้ว เราไม่ต้องสนใจสิ่งที่ทำในส่วนระดับล่าง หรือ ระดับ Hardware แต่เรามาสนใจสิ่งที่ทำบนระดับสูงเลยว่า เราจะต้องส่ง รับค่าอะไร และต้องตั้งค่าอัตราเร็วในการส่งให้เท่ากัน หรือ ตั้งค่า baud rate เท่าไร แค่นี้เราก้อรับส่งข้อมูลกับคอมพิวเตอร์ได้แล้ว

รู้จักคำสั่งของ Arudino ที่ใช้ใน serial

void serial.begin(rate) กำหนดอัตราบอดของการรับส่งข้อมูล หน่วยเป็นบิตต่อวินาที่ (bits per second :bps baud rate)
int serial.available() ใช้ตรวจสอบว่า buffer รับข้อมูลไว้หรือไม่ โดยจะคืนค่าจำนวนไบต์ที่อยู่ในบัฟเฟอร์
int serial.read() ส่งค่าที่รับจากพอร์ตอนุกรมออกมา (Serial)
void Serial.flush() เคลียร์บัฟเฟอร์ของพอร์ตอนุกรม(Serial) ให้ว่าง
void Setial.print() พิมพ์ข้อมูล ออกทางพอร์ตอนุกรม
void Setial.println() พิมพ์ข้อมูล ออกทางพอร์ตอนุกรม แต่ขั้นบรรทัดใหม่ด้วย

คุยกับคอมพิวเตอร์

เรามาลองเอาง่ายๆกัน ครับ โดยตัวอย่างแรกให้ทดลองส่งข้อมูลดูก่อนครับ ไม่กี่บรรทัด ก็เสร็จแล้วพิมพ์ตามกันไปเลย ตามตัวอย่างข้างล่างนี้

int counter = 0;

void setup() {
 Serial.begin(9600);
 Serial.println("Hello Serial");
 delay(100);
}

void loop() {
 counter++;

 Serial.println(counter);

 if (counter == 25)  {
 counter = 0;
 }

 delay(100);
}

หลังจาก Upload sketch นี้ ให้เปิด Serial Monitor นะครับ แล้วเลือกจะเห็นข้อความขึ้นมาเป็น คำทักทาย “Hello Serial “ และ ตามด้วยตัวเลข 1 ถึง 25 แต่ถ้ามันขึ้นมาเป็นภาษาแปลกๆ ก้อแสดงว่า ความเร็วในการรับส่งข้อมูลของ arduino กับ computer อาจจะไม่ตรงกัน ควรจะตั้งค่าควรตั้งค่า baud rate กันใหม่ครับ

ถ้าใครรู้สึกว่า ตั้งค่า BaudRate แก้ไขที่นี้ครับ ในช่อง Serial Monitor ทางขวาจะมีช่องค่า Baudrate เลือกค่าที่ถูกต้องในตามโปรแกรม ค่าความเร็วกับรับส่งจะเป็นตัวเลขลงตัว 600, 1200, 4800, 9600, 19200, 38400, 57600, 1115200 ปกติเราจะใช้ค่า 9600

สิ่งที่อยากให้ลองคือ ภายในฟังก์ชั่น Serial.println( value ,format) สามารถจะส่งค่า ออกมาในรูปแบบอื่นได้ ไม่ว่าจะเป็น แบบตัวอักษร(BYTE), เลขฐานสอง(BIN), เลขฐานแปด(OCT), เลขฐานสิบ(DEC), เลขฐานสิบหก(HEX), ข้อความ ลองเปลี่ยน Serial.println(counter); เป็น Serial.println(counter, BYTE) และอื่นๆ ดูตามตัวอย่างข้างล่าง

Serial.println (78, BYTE)                                  “N”

Serial.println (78, BIN)                                    “1001110″

Serial.println (78, OCT)                                   “116″

Serial.println (78, DEC)                                   “78″

Serial.println (78, HEX)                                   “4E”

Serial.println(1.23456, 0)                                 “1″

Serial.println(1.23456, 2)                                 “1.23″

Serial.println(1.23456, 4)                                 “1.2346″

ส่งกลับจากคอมพิวเตอร์ไป Arduino บ้าง

หลังจากที่เราส่งออกไปได้แล้ว มาทดลองรับค่าจากคอมพิวเตอร์บ้าง วิธีการรับข้อมูลเข้าจากคอมพิวเตอร์ arduino จะใช้ฟังก์ชั่น Serial.Read() ซึ่งในตัวอย่างนี้ช่วยให้เข้าใจมากขึ้น หลังจาก upload อย่าลืม เปิด Serial Monitor แล้วทดลองตามล่ะ

int incomingByte = 0;
void setup() {
    Serial.begin(9600);
    Serial.println("Hello ,type something");
}

void loop() {
     if (Serial.available() > 0) {
         incomingByte = Serial.read();
         Serial.print ("> ");
         Serial.println (incomingByte,BYTE);
     }
}

serial.read() จะเป็นฟังก์ชั่น ที่คืนค่ารับมาจาก serial ซึ่งในที่นี้เป็นตัวอักษร จะนำมาใช้งานเราจึงต้องประกาศตัวแปร มารับค่า และนำค่าไปประมวลผลต่อไป สำหรับในโปรแกรมนี้ เราได้รับค่า และพิมพ์ค่าออก Serial Monitor โดยเพิ่ม “>” เข้าไปข้างหน้าด้วย

ควบคุมไฟกระพริบด้วย Serial

หลังจากที่เราควบคุมไฟกระพริบเบื้องต้นไปได้แล้ว ในตอนที่ 1 มาตอนนี้เราจะให้ลองทำ ไฟกระพริบควบคุมจากคอมพิวเตอร์ได้อย่างง่ายครับ โดยการส่งตัวอักษร “a” เพื่อทำให้ LED มันกระพริบ

int incomingByte = 0;
int ledPin = 13;

void setup() {
   Serial.begin(9600);
   Serial.println ("Type 'a' for blinky");
}

void loop() {
    if (Serial.available() > 0)     {
          incomingByte = Serial.read();
          Serial.print ("> ");
          Serial.println (incomingByte,BYTE);

          if (incomingByte == 'a') {
              Blinky();
          }
    }
} 

void Blinky(void) {
     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
}

วิธีการใช้งาน หลังจากเขียนโปรแกรมเสร็จ เปิด serial monitor แล้วใส่ค่าตัวอักษร ‘a’ ลงไป จะเห็นว่าไฟกระพริบทำงานได้ และพิมพ์ข้อความกลับมาว่า “test blinky” ดูภาพประกอบไปด้วย

น่าจะเป็นตัวอย่างให้กับเพื่อนๆที่กำลังอยากทำอุปกรณ์ ควบคุมผ่านคอมได้นะครับ ถ้าเปลี่ยนจาก LED เป็น Relay สามารถเปิดปิดอุปกรณ์ที่ใหญ่กว่านี้ได้แล้ว สำหรับการใช้งานจริงเราอาจจะออกแบบการรับคำสั่งที่เป็นรูปแบบ protocol ซึ่งจะเอาไว้กล่าวต่อไปครับ

จบไปอีก หนึ่งตอน จะเห็นว่าการเขียนโปรแกรมไม่ได้ยากเลยครับ ค่อยๆเพิ่มเติม และออกแบบวิธีคิดที่ดีครับ วิธีการฝึกเขียนโปรแกรมที่ดีที่สุด คือลงมือทำบ่อยๆครับ แล้วลองแก้ไข โปรแกรมตัวอย่าง ของเราให้ไปด้วย จะช่วยให้เป็นได้เร็วขึ้นมากครับ แล้วเจอกันใหม่ตอนหน้าครับ

No related posts.

[Sciguy14] Arduino Tutorial 4: Analog Inputs

chang — Mon, 24 Jan 2011 18:44:53 +0000

แล้วครับ Tutorial ไม่รู้จะเรียนรู้กันทันไหม สำหรับตอน 4 จะเกี่ยวโยงกับตอนที่ 3 นะครับ หลังจากที่ได้ศึกษาเกี่ยวกับสัญญาณ analog แล้วสำหรับในตอนนี้ เรามาทดลองต่อเกี่ยวกับ เขียนโปรแกรมรับค่า analog กันต่อบ้าง ดูเพลินๆ สนุกๆ นะครับ

This week is all about analog inputs for the arduino. I’ll show you how you can use a voltage divider circuit (see episode 3) and a variable resistor to make an analog sensor. We’ll also use a Sharp IR distance sensor as an analog input to detect distance and movement (with some clever programming). By the end of this episode, you will be able to create your own emergency lighting system! Without further adieu, check out this week’s tutorial on analog inputs for the arduino.

โดยรวมวีดีโอนี้ จะประกอบไปด้วย analogRead() กับวิธีต่อวงจรไฟฟ้าเพื่อสร้างเป็นเซ็นเซอร์ส่งค่ามาให้ arduino ได้

No related posts.

[Sciguy14] Arduino Tutorial 03: ความรู้พื้นฐานวิศวกรรมไฟฟ้า

chang — Wed, 19 Jan 2011 15:11:08 +0000

มาแล้วตอนที่ 3 ของ Jeremy Blum ขยันออกมาก ผมยังทำไม่ทันเลย รู้สึกว่าจะแพ้เรื่องความหนุ่ม วีดีโอดี บทความเด่น ทำได้ไงนิ สำหรับตอนสาม จะเกี่ยวกับพื้นฐานทางไฟฟ้าครับ ทั้งเรื่อง “กฏของ Ohm” , “Pull-down” , “Pull-up” และอีกเรื่อง “Voltage-divider” ซึ่งเป็นพื้นฐานที่ต้องรู้นะครับ สำหรับงานทางไมโครคอนโทรลเลอร์

สำหรับตอนนี้ไม่มี arduino นะครับ ทดลองพื้นฐานล้วนๆ ใครยังไม่ทราบเลยดูตามกันไปครับ

In this week’s arduino tutorial, we take a bit of a detour and focus on some key elements of electrical engineering design that we’ll be using in future episodes. Included amongst these topics is Ohm’s Law, current-limiting resistors, pull-down and pull-up resistors, voltage dividers, potentiometers, analog inputs, and voltage regulators.

If you’re yearning to learn more after watching this video, I’d suggest you check out Jeri Ellsworth and Dave Jones on youtube. They offer videos about everything from circuit design to pinball machines.

You can download the files associated with this episode here:

Episode 03 Arduino Programs

Episode 03 Parts List

Episode 03 Schematics

No related posts.