เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบ้อื งตน้ 1หน่วยที่ 3 โครงสร้างโปรแกรมของ ARDUINO สาระสาคญั ในการเขียนโปรแกรมสาหรับบอร์ด Arduino จะต้องเขียนโปรแกรมโดยใช้ภาษาของ Arduino (ArduinoProgramming Language) ซ่ึงตัวภาษาของ Arduino ก็นาเอาโอเพ่นซอร์สโปรเจ็กต์ชื่อ Wiring มาพัฒนาต่อ ภาษาของ Arduino แบง่ ไดเ้ ป็น 2 สว่ นหลกั คอื โครงสรา้ งภาษา (Structure) ตวั แปร ค่าคงที่และฟงั ก์ชั่น (Function)ภาษาของ Arduino จะอ้างอิงตามภาษา C/C++ จึงอาจกล่าวได้ว่าการเขียนโปรแกรมสาหรับ Arduino (ซึ่งก็รวมถึงบอรด์ Arduino) กค็ อื การเขยี นโปรแกรมภาษา C โดยเรยี กใชฟ้ ังกช์ ัน่ และไลบรารที ่ีทาง Arduino ไดเ้ ตรียมไวใ้ หแ้ ลว้เน้อื หาสาระการเรยี นรู้ 3.1 ส่วนของฟังกช์ ั่น setup() 3.2 ส่วนของฟังก์ชน่ั loop() 3.3 ส่วนของตวั กระทาทางคณิตศาสตร์ 3.4 ส่วนของตัวกระทาเปรียบเทยี บ 3.5 ส่วนของตวั กระทาระดับบิต 3.6 ไวยากรณ์ภาษา C / C++ ของ Arduino 3.7 ตวั แปร 3.8 ขอบเขตของตัวแปร 3.9 การกาหนดค่าคงท่ีเลขจานวนเตม็ เปน็ เลขฐานตา่ งๆ ของ Arduino 3.10 คา่ คงท่ี (constants) 3.11 ตวั กระทาอ่นื ๆ ทเี่ กี่ยวขอ้ งกบั ตัวแปร 3.12 คาสงวนของ Arduinoจดุ ประสงคก์ ารเรยี นรู้ จดุ ประสงค์ทวั่ ไป1. เพ่ือให้มีความร้คู วามเข้าใจเก่ียวกับลักษณะโครงสรา้ งโปรแกรมของ Arduino2. เพื่อให้สามารถนาความรู้ไปประยุกต์ใช้ในการเขียนโปรแกรมกาหนดการทางานของ Arduino3. เพ่ือใหต้ ระหนกั ถึงความสาคญั ของลักษณะโครงสร้างโปรแกรมของ Arduinoหน่วยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรียงโดยครูทนั พงษ์ ภ่รู ักษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บื้องต้น 2จุดประสงคเ์ ชงิ พฤตกิ รรม1. บอกหน้าทีก่ ารทางานสว่ นของฟังก์ชน่ั ได้2. บอกหน้าท่กี ารทางานสว่ นของฟังก์ชน่ั setup() ได้3. บอกหนา้ ท่ีการทางานสว่ นของฟังกช์ น่ั loop() ได้4. บอกหน้าที่การทางานของตัวกระทาทางคณิตศาสตรไ์ ด้5. บอกหน้าท่กี ารทางานส่วนของตัวกระทาเปรยี บเทียบได้6. ใชง้ านสว่ นของตวั กระทาระดบั บติ ได้7. ใชง้ านไวยากรณ์ภาษา C / C++ ของ Arduinoได้8. ใชง้ านตัวแปรได้หนว่ ยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรยี งโดยครูทันพงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบอื้ งตน้ 3แบบทดสอบก่อนเรียน หนว่ ยที่ 3เร่ือง โครงสร้างโปรแกรมของ Arduinoเรอ่ื ง โครงสร้างโปรแกรมของ Arduino ใชเ้ วลา 20 นาทีวชิ า ไมโครคอนโทรลเลอร์เบ้อื งตน้ รหัสวิชา (2127-2107)ระดับชน้ั ประกาศนียบตั รวชิ าชีพ (ปวช.) สาขาวชิ า เมคคาทรอนิกส์*****************************************************************************************คาชแ้ี จง 1. แบบทดสอบมที ัง้ หมด 10 ข้อ (10 คะแนน) 2. ให้ผู้เรียนเลอื กคาตอบทถ่ี ูกที่สุดแล้วกาเครอ่ื งหมายกากบาท () ลงในกระดาษคาตอบ1. ภาษาของ Arduino แบง่ ได้เป็น 2 ส่วนหลกั คอื ก. โครงสรา้ งภาษา / ฟงั ก์ช่นั ข. ตวั แปร / ไวยกรณ์ ค. ฟงั ก์ชัน่ / ตัวกระทา ง. ตวั กระทา / ตวั เปรียบเทยี บ2. โครงสรา้ งโปรแกรมของ Arduino แบง่ ได้เป็นสองส่วนคอื ก. void up() และ void loop() ข. void set() และ void setup() ค. void setup () และ void looping() ง. void setup() และ void loop()3. ฟังก์ชั่น loop() ซ่งึ มีการทางานแบบใด ก. ทางานแบบวนรอบต่อเนือ่ งตลอดเวลา ข. ทางานแบบวนรอบ 5 ครง้ั ค. ทางานแบบวนรอบ 10 ครัง้ ง. ทางานวนแบบวนรอบ 15 ครั้ง4. คาสัง่ if...else ใชเ้ พ่ือกาหนดเง่ือนไขการทางานของโปรแกรมอยา่ งไร ก. ถ้าเงือ่ นไขเป็นจริงใหท้ าอะไร ถ้าเปน็ เท็จใหท้ าอะไร ข. ไม่สามารถทาอะไรไดอ้ ีกแลว้ ค. ถ้าเงอ่ื นไขเปน็ จรงิ ให้ทาอะไร ง. ถ้าเงื่อนไขเป็นเทจ็ ใหท้ าอะไรหน่วยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรยี งโดยครูทนั พงษ์ ภูร่ กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บ้อื งตน้ 45. ตวั กระทาทางคณติ ศาสตร์ ประกอบด้วย ก. + (บวก),- (ลบ), * (คู ณ), / (หาร) และ % (หารเอาเศษ) ข. + (บวก),- (ลบ), * (คู ณ), / (หาร) และ % (หารไม่เอาเศษ) ค. * (คณู ), / (หาร) และ % (หารเอาเศษ) ง. + (บวก),- (ลบ), และ % (หารเอาเศษ)6. ตวั กระทาระดบั บิต AND ใช้สัญญลกั ษณใ์ ด ก. && ข. AND ค. และ ง. &7. ตัวกระทาระดบั บิต OR ใช้สญั ญลักษณ์ใด ก. I ข. II ค. หรือ ง. OR8. คาสง่ั ระดบั บติ Exclusive OR ใชส้ ัญญลกั ษณใ์ ด ก. ^ ข. $ ค. ƒ ง. ∞9. ไวยากรณ์ภาษา C เซมิโคลอน (semicolon ; ) ใช้ทาหนา้ ท่ีใด ก. ใช้เขยี นแจ้งว่าจบคาสงั่ ข. ใชเ้ ขยี นแจ้งวา่ เรมิ่ คาสั่ง ค. ใช้เขยี นแจง้ วา่ ลบคาสัง่ ง. ใช้เขียนแจง้ ว่าเพมิ่ คาสง่ั10. ตวั แปรประเภทเลขทศนยิ มคือ ก. long ใชพ้ ืน้ ทห่ี นว่ ยความจา 2 ไบต์ ข. float ใชพ้ นื้ ทห่ี น่วยความจา 2 ไบต์ ค. long ใช้พนื้ ทหี่ น่วยความจา 4 ไบต์ ง. float ใช้พ้ืนท่ีหนว่ ยความจา 4 ไบต์หนว่ ยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครทู นั พงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บ้อื งตน้ 5 หนว่ ยที่ 3โครงสร้างโปรแกรมของ Arduino ในการเขยี นโปรแกรมสาหรับบอร์ด Arduino จะต้องเขียนโปรแกรมโดยใช้ภาษาของ Arduino (ArduinoProgramming Language) ซึ่งตัวภาษาของ Arduino กน็ าเอาโอเพ่นซอร์สโปรเจก็ ต์ช่ือ Wiring มาพัฒนาต่อ ภาษาของ Arduino แบ่งได้เป็น 2 ส่วนหลักคอื 1. โครงสร้างภาษา (Structure) ตัวแปรและค่าคงท่ี 2. ฟงั ก์ช่ัน (Function) ภาษาของ Arduino จะอา้ งอิงตามภาษา C/C++ จงึ อาจกล่าวไดว้ ่าการเขียนโปรแกรมสาหรับ Arduino(ซึ่งกร็ วมถงึ บอร์ด Arduino) กค็ อื การเขยี นโปรแกรมภาษา C โดยเรยี กใช้ฟงั กช์ ั่นและไลบรารีทท่ี าง Arduino ได้เตรยี มไวใ้ ห้แลว้ ซึง่ สะดวกและทาใหผ้ ้ทู ่ไี ม่มคี วามร้ดู า้ นไมโครคอนโทรลเลอรอ์ ย่างลกึ ซงึ้ สามารถเขียนโปรแกรมสั่งงานได้ ในบทนจี้ ะอธิบายถึงโครงสร้างโปรแกรมของ Arduino แบ่งได้เป็นสองส่วนคือ void setup() และ voidloop() โดยฟังก์ช่ัน setup() เมื่อโปรแกรมทางานจะทาคาสั่งของฟังก์ช่ันนี้เพียงครั้งเดียว ใช้ในการกาหนดค่าเร่ิมตน้ ของการทางานสว่ นฟังก์ช่ัน loop() เป็นส่วนทางานโปรแกรมจะทาคาส่ังในฟังกช์น่ันต่อเนื่องกันตลอดเวลาโดยปกตใิ ช้กาหนดโหมดการทางานของขาตา่ งๆ กาหนดการสอ่ื สารแบบอนุกรม ฯลฯ ส่วนของ loop() เป็นโค้ดโปรแกรมท่ที างาน เช่น อา่ นคา่ อินพุต ประมวลผล สั่งงานเอาต์พุต ฯลฯ โดยส่วนกาหนดค่าเร่ิมต้น เช่นตัวแปรจะต้องเขียนท่ีส่วนหัวของโปรแกรมก่อนถึงตัวฟังก์ช่ัน นอกจากนั้นยังต้องคานึงถึงตวั พิมพ์ เล็ก-ใหญ่ ของตัวแปรและช่ือฟงั กชน์ ้นั ใหถูกต้อง 3.1 สว่ นของฟงั ก์ช่ัน setup() ฟังกช์ ัน่ นจ้ี ะเขยี นทส่ี ว่ นตน้ ของโปรแกรม ทางานเมอื่ โปรแกรมเรมิ่ ตน้ เพียงคร้งั เดียว ใชเ้ พื่อกาหนดค่าของตวั แปรโหมดการทางานของขาตา่ งๆ เริ่มตน้ เรียกใชไ้ ลบรารี ฯลฯ ตัวอยา่ งท่ี 3.1 int buttonPin = 13; void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); }หน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรยี งโดยครทู ันพงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบือ้ งตน้ 6 void loop() { if (digitalRead(buttonPin) == HIGH) Serial.println('H'); else Serial.println('L'); delay(1000); } ในขณะที่โปรแกรมภาษา C มาตรฐานท่ีเขียนบน AVR GCC (เป็นโปรแกรมภาษา C ที่ใช้ C คอมไพเลอร์แบบ GCC สาหรับไมโครคอนโทรลเลอร์ AVR) จะเขียนได้ ดังน้ี int main(void) { init(); setup(); for (;;) loop(); return ; } 3.2 สว่ นของฟังกช์ ั่น loop() หลังจากทเ่ี ขียนฟังก์ชั่น setup() ท่ีกาหนดค่าเริ่มต้นของโปรแกรมแล้ว ส่วนถัดมาคือฟังก์ช่ัน loop() ซึ่งมีการทางานตรงตามช่อื คือจะทางานตามฟังก์ช่ันวนต่อเน่ืองตลอดเวลา ภายในฟังก์ช่ันจะมีโปรแกรมของผู้ใช้เพ่ือรับคา่ จากพอร์ต ประมวลผลแลว้ สงั่ เอาต์พุตออกขาตา่ งๆ เพื่อควบคมุ การทางานของบอร์ด ตัวอย่างท่ี 3.2 int buttonPin = 13; // setup initializes eerial and the button pin void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); } // loop checks the button pin each time,หน่วยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรียงโดยครทู ันพงษ์ ภ่รู กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้อื งต้น 7 // and will send serial if it is pressed void loop() { if (digitalRead(buttonPin) == HIGH) Serial.println('H'); else Serial.println('L'); delay(1000); } โปรแกรมทางานวนในฟงั ก์ชน่ั loop() ตลอดเวลา หลังจากทางานในฟังก์ชั่น setup() จึงสรุปได้ว่าฟังก์ช่ันsetup() คือส่วนตน้ ของโปรแกรมที่ใชใ้ นการประกาศ หรือต้ังค่าการทางานในตอนเร่ิมต้นทางาน ในขณะที่ฟังก์ชั่นloop() เปน็ เสมอื นส่วนของโปรแกรมหลักที่ต้องวนทางานอย่างต่อเน่ืองตลอดเวลา อย่างไรก็ตามในบางโปรแกรมอาจมีเฉพาะส่วนของฟังก์ชั่น setup() และไม่มีฟังก์ช่ัน loop() ก็ได้ น่ันแสดงว่าโปรแกรมนั้นๆต้องการต้ังค่าการทางาน หรือกาหนดใหม้ ีการทางานเพียงคร้งั หรอื รอบเดียว แลว้ จบการทางานทนั ที 3.2.1 คาส่ัง if ใชท้ ดสอบเพอ่ื กาหนดเงอื่ นไขการทางานของโปรแกรม เชน่ ถ้าอนิ พุตมคี ่ามากกว่าค่าทีก่ าหนดไว้ จะให้ทาอะไรโดยมรี ูปแบบการเขียนดังนี้ if (somevariable > 50) { // do something Here } ตัวโปรแกรมจะทดสอบว่าถา้ ตัวแปร someVariable มีค่ามากกว่า 50 หรือไม่ ถ้าใช่ให้ทาอะไร ถ้าไม่ใช่ให้ข้ามการทางานส่วนน้ี การทางานของคาสั่งน้ีจะทดสอบเง่ือนไขที่เขียนในเคร่ืองหมายวงเล็บ ถ้าเงื่อนไขเป็นจริงทาตามคาสั่งท่ีเขียนในวงเล็บปีกกา ถ้าเง่ือนไขเป็นเท็จข้ามการทางานส่วนน้ีไป ส่วนของการทดสอบเงื่อนไขที่เขียนอยู่ภายในวงเล็บ จะตอ้ งใชต้ ัวกระทาเปรยี บเทยี บตา่ งๆ ดังนี้ x == y (x เทา่ กับ y) x != y (x ไม่เทา่ กับ y) x < y (x น้อยกวา่ y) x > y (x มากกวา่ y) x <= y (x น้อยกว่าหรอื เท่ากับ y) x >= y (x มากกว่าหรอื เท่ากับ y) เทคนิคสาหรับการเขียนโปรแกรมในการเปรียบเทียบตัวแปรให้ ใช้ตัวกระทา == (เช่น if (x==10)) ห้ามหนว่ ยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรียงโดยครูทันพงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบ้อื งตน้ 8เขียนผิดเป็น = (เช่น if (x=10)) คาสง่ั ที่เขียนผิดในแบบท่ีสองนี้ ทาให้ผลการทดสอบเป็นจริงเสมอ และเมื่อผ่านคาสั่งแล้ว x มีค่าเท่ากับ 10 ทาให้การทางานของโปรแกรมผิดเพี้ยนไปไม่เป็นตามที่กาหนดไว้ เราสามารถใช้คาสั่งif ในคาสัง่ ควบคุมการแยกเส้นทางของโปรแกรมโดยใช้คาส่ัง if....else 3.2.2 คาสงั่ if...else ใช้ทดสอบเพอ่ื กาหนดเงื่อนไขการทางานของโปรแกรมได้มากกว่าคาส่ัง if ธรรมดา โดยสามารถกาหนดได้ว่าถ้าเง่ือนไขเป็นจริงให้ทาอะไร ถ้าเป็นเท็จให้ทาอะไร เช่นถ้าค่าอินพุตแอนะล็อกท่ีอ่านได้น้อยกว่า 500 ให้ทาอะไร ถ้าค่ามากกว่าหรอื เทา่ กับ 500 ใหท้ าอีกอย่าง จะเขยี นคาสงั่ ไดด้ ังนี้ ตัวอย่างท่ี 3.3 if (pinFiveInput < 500) { // do thing A } else { // do thing B } หลังคาส่ัง else สามารถตามด้วยคาสั่ง if สาหรับการทดสอบอื่นๆ ทาให้รูปแบบคาสั่งกลายเป็นif....else...if เป็นการทดสอบเง่อื นไขตา่ งๆ เมอื่ เปน็ จรงิ ใหท้ าตามที่ต้องการดังตวั อยา่ งต่อไปนี้ ตัวอย่างท่ี 3.4 if (pinFiveInput < 500) { // do Thing A } else if (pinFiveInput >= 1000) { // do Thing B } else { // do Thing C } หลังคาสั่ง else สามารถตามด้วยคาสั่ง if ได้ไม่จากัดจานวน (สามารถใช้คาส่ัง switch case แทนคาสั่งหน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทนั พงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บือ้ งตน้ 9if...else...if สาหรับการทดสอบเงื่อนไขจานวนมากๆ ได้) เมือ่ ใชค้ าส่ัง if...else แล้วต้องกาหนดด้วยว่าถ้าทดสอบไม่ตรงกับเง่ือนไขใดๆเลย ให้ทาอะไรโดยให้กาหนดทีค่ าสั่ง else ตัวสุดท้าย 3.2.3 คาสงั่ for() คาส่ังนี้ใช้เพ่ือสั่งให้คาส่ังท่ีอยู่ภายในวงเล็บปีกกาหลัง for มีการทางานซ้ากันตามจานวนรอบที่ต้องการคาสง่ั น้มี ีประโยชน์มากสาหรับการทางานใดๆท่ีต้องทาซ้ากัน และทราบจาานวนรอบของการทางานท่ีแน่นอน ใช้คู่กับตัวแปรอะเรย์ในการเก็บสะสมค่าท่ีอ่านค่าได้จากขาอินพุตแอนะล็อกหลายๆขา ที่มีหมายเลขขาต่อเนื่องกันรูปแบบของคาสั่ง for() แบง่ ได้ 3 ส่วนดังน้ี for (initialization; condition; increment) { //statement(s); } เริ่มตน้ ด้วย initialization ใช้กาหนดคา่ เร่ิมตน้ ของตวั แปรควบคมุ การวนรอบในการทางานแต่ละรอบจะทดสอบ condition ถา้ เงื่อนไขเปน็ จริงทาตามคาส่งั ในวงเล็บปกี กา แล้วมาเพิ่มหรือลดคา่ ตวั แปรตามทสี่ ่ังในincrement แลว้ ทดสอบเงือ่ นไขอีก ทาซา้ จนกว่าเงอื่ นไขเป็นเท็จ ตัวอยา่ งท่ี 3.5 for (int i=1; i <= 8; i++) { // statement using the value i; } คาสง่ั for ของภาษา C ยืดหยนุ่ กว่าคาสงั่ for ของภาษาคอมพิวเตอร์อ่ืนๆ มันสามารถละเว้นบางส่วนหรือทง้ั สามสว่ นของคาสั่ง for ได้ อยา่ งไรก็ตามยังต้องมีเซมิโคลอน นอกจากน้ันยังนาคาส่ังภาษา C++ ที่มีตัวแปรท่ีไม่เกยี่ วขอ้ งมาเขียนในส่วนของ initialization condition และ increment ของคาส่ัง for ได้ 3.2.4 คาส่ัง switch-case ใช้ทดสอบเง่ือนไขเพื่อกาหนดการทางานของโปรแกรม ถ้าตัวแปรท่ีทดสอบตรงกับเงื่อนไขใดก็ให้ทางานตามทีก่ าหนดไว้พารามิเตอร์ var ตวั แปรทต่ี ้องการทดสอบว่าตรงกับเง่ือนไขใด default ถ้าไม่ตรงกบั เงือ่ นไขใดๆเลย ให้ทาคาส่งั ต่อทา้ ยน้ี break เป็นส่วนสาคัญมากใช้เขียนต่อท้าย case ต่างๆ เม่ือพบเง่ือนไขนั้นแล้วทาตามคาสั่งต่างๆแล้ว ให้หยดุ การทางานของคาส่งั switch-case ถ้าลมื เขียน break เม่ือพบเงื่อนไขทาตามเงื่อนไขแล้วโปรแกรมจะทางานตามเงื่อนไขต่อไปเรอ่ื ยๆ จนกวา่ จะพบคาส่ัง breakหนว่ ยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทันพงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บอ้ื งตน้ 10 ตัวอยา่ งที่ 3.6 switch (var) { case 1: //do something when var == 1 break; case 2: //do something when var == 2 break; default: // if nothing else matches, do the default } 3.2.5 คาสง่ั while เป็นคาสั่งวนรอบโดยจะทาคาสั่งที่เขียนในวงเล็บปีกกาอย่างต่อเนื่อง จนกว่าเงื่อนที่เขียนในวงเล็บของคาส่ัง while() จะเป็นเท็จ คาสง่ั ทใี่ ห้ทาซ้าจะตอ้ งมีการเปล่ียนแปลงค่าตัวแปรท่ีใช้ทดสอบ โดยมีการเพิ่มค่าตัวแปรหรอื มเี งือ่ นไขภายนอก เช่นอา่ นคา่ จากตวั ตรวจจบั ได้เรียบร้อยแล้วให้หยดุ การอ่านค่า มิฉะน้ันเง่ือนไขในวงเล็บของwhile() เปน็ จรงิ ตลอดเวลา ทาให้คาสัง่ while ทางานวนรอบไปเร่ือยๆ ไม่รู้จบ รปู แบบคาส่ั ง while(expression) { // statement(s) } พารามิเตอร์ expression เป็นคาสัง่ ทดสอบเงือ่ นไข (ถกู หรือผิด) ตัวอยา่ งท่ี 3.7 var = 0; while(var < 200) { // do something repetitive 200 times var++; }หน่วยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรยี งโดยครทู ันพงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบ้ืองต้น 11 3.3 ส่วนของตวั กระทาทางคณติ ศาสตร์ ประกอบด้วยตัวกระทา 5 ตวั คอื + (บวก),- (ลบ), * (คู ณ), / (หาร) และ % (หารเอาเศษ) 3.3.1 ตวั กระทาทางคณิตศาสตร์ บวก ลบ คูณ และหาร ใช้หาค่าผลรวม ผลต่าง ผลคูณ และผลหาร ค่าของตัวถูกกระทาสองตัวโดยให้คาตอบมีประเภทตรงกับตัวถูกกระทาท้ังสองตัว เช่น 9/4 ให้คาตอบเท่ากับ 2 เน่ืองจากท้ัง 9 และ 4 เป็นตัวแปรเลขจานวนเต็ม (int) นอกจากนตี้ ัวกระทาทางคณิตศาสตร์อาจทาให้เกิดโอเวอร์โฟลว์ (overflow) ถ้าผลลัพธ์ที่ได้มีขนาดใหญ่เกนิ กว่าจะสามารถเก็บในตวั แปรประเภทนนั้ ถา้ ตัวทีถ่ ูกกระทาต่างประเภทกันผลลัพธ์ที่ได้ เช่น 9/4 = 2หรือ 9/4.0 = 2.25 รูปแบบคาส่ัง result = value1 + value2; result = value1 - value2; result = value1 * value2; result = value1 / value2; พารามิเตอร์ value1 : เป็นคา่ ของตัวแปรหรือคา่ คงที่ใดๆ value2: เป็นค่าของตวั แปรหรือค่าคงท่ี ใดๆ ตัวอย่างท่ี 3.8 y = y + 3; x = x - 7; i = j * 6; r = r / 5; เทคนิคสาหรับการเขยี นโปรแกรม เลือกขนาดของตัวแปรให้ใหญ่พอสาหรับเกบ็ ค่าผลลพั ธ์ทมี่ ากท่ีสดุ ของการคานวณ ต้องทราบว่าที่ค่าใดตัวแปรที่เก็บจะมีการวนซ้าคา่ กลับ และวนกลบั อยา่ งไร ตัวอยา่ งเช่น (0 ไป 1) หรือ (0 ไป -32768) สาหรับการคาณวณท่ีต้องการเศษส่วนให้ใช้ตัวแปรประเภท float แต่ให้ระวังผลลบ เช่นตัวแปรมีขนาด ใหญ่ คานวณได้ช้า ใชต้ ัวกระทา cast เชน่ (int)myfloat ในการเปล่ยี นประเภทของตวั แปรชั่วคราวขณะที่โปรแกรมทางาน 3.3.2 ตวั กระทา % หารเอาเศษ ใชห้ าค่าเศษท่ีได้ของการหารเลขจานวนเต็ม 2 ตวั ตัวกระทาหารเอาเศษไมส่ ามารถใช้งานกบั ตัวแปรเลขทศนิยม (float) รูปแบบคาสั่ง result = value1 % value2;หน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครูทันพงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้อื งต้น 12 พารามิเตอร์ value1 - เป็นตัวแปรประเภท byte,char,int หรือ long value2 - เปน็ ตัวแปรประเภท byte,char,int หรือ long ผลที่ไดเ้ ศษจากการหารคา่ เลขจานวนเตม็ เป็นขอ้ มลู ชนิดเลขจานวนเต็ม ตัวอย่างท่ี 3.9 x = 7 % 5; // x now contains 2 x = 9 % 5; // x now contains 4 x = 5 % 5; // x now contains 0 x = 4 % 5; // x now contains 4 ตัวกระทาหารเอาเศษนีใ้ ชป้ ระโยชน์มากในงานท่ีตอ้ งการใหเ้ หตุการณ์เกดิ ข้ึนดว้ ยช่วงเวลาที่สมา่ เสมอหรอื ใช้ทาให้หน่วยความจาที่เกบ็ ตวั แปรอะเรย์ เกดิ การส่งค่ากลับ (Roll Over) ตัวอยา่ งที่ 3.10 // check a sensor every 10 times through a loop void setup() { i++; if ((i % 10) == 0) { x = analogRead(sensPin); // read sensor every ten times through loop } } // setup a buffer that averages the last five samples of a sensor int senVal[5]; // create an array for sensor data int i, j; // counter variables long average; // variable to store average void loop() { // input sensor data into oldest memory slot senVal[(i++) % 5] = analogRead(sensPin); average = 0; for (j=0; j<5; j++) {หนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรียงโดยครทู นั พงษ์ ภรู่ ักษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบ้อื งตน้ 13 average += sensVal[j]; // add samples } average = average / 5; // divide by total } 3.4 สว่ นของตัวกระทาเปรยี บเทยี บใช้ประกอบกับคาส่ัง if() และ while() เพอื่ ทดสอบเงอื่ นไขหรือเปรียบเทียบค่าตัวแปรต่างๆ โดยจะเขียนเป็นนิพจน์อยู่ภายในเคร่ืองหมาย () x == y (x เท่ากับ y) x != y (x ไม่เทา่ กั บ y) x < y (x นอ้ ยกวา่ y) x > y (x มากกว่า y) x <= y (x นอ้ ยกวา่ หรือเท่ากับ y) x >= y (x มากกว่าหรือเท่ากับ y) ใชใ้ นการเปรยี บเทียบของคาส่ัง if() มี 3 ตวั คอื &&, || และ ! 3.4.1 && (ตรรกะ และ) ให้ค่าเปน็ จรงิ เม่อื ผลการเปรยี บเทียบท้งั สองข้างเปน็ จรงิ ท้ังคู่ ตัวอยา่ งที่ 3.11 if (x > 0 && x < 5) { // ... } ใหค้ า่ เป็นจริงเม่ือ x มากกวา่ 0 และน้อยกวา่ 5 (มคี า่ 1 ถึ ง 4) 3.4.2 || (ตรรกะ หรือ) ใหค้ า่ เป็นจรงิ เมอ่ื ผลการเปรยี บเทียบพบว่า มีตวั แปรใดเป็นจริงหรอื เป็นจริงทั้งคู่ ตัวอยา่ งที่ 3.12 if (x > 0 || y > 0) { // ... } ให้ผลเปน็ จริงเมื่อ x หรือ y มีค่ามากกว่า 0 3.4.3 ! (ใชก้ ลับผลเปน็ ตรงกันข้าม) ใหค้ ่าเปน็ จริงเมอ่ื ผลการเปรยี บเทียบเป็นเท็จหน่วยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรยี งโดยครูทนั พงษ์ ภรู่ ักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบื้องต้น 14 ตัวอยา่ งท่ี 3.13 if (!x) { // ... } ใหผ้ ลเป็นจริงถ้า x เปน็ เทจ็ (เช่น ถ้า x = 0 ให้ผลเปน็ จริง) 3.4.4 ข้อควรระวัง ระวังเร่ืองการเขียนโปรแกรม ถ้าต้องการใช้ตัวกระทาตรรกะ และต้องเขียนเคร่ืองหมาย && ถ้าลืมเขียนเป็น & จะเป็นตัวกระทา และระดับบิตกับตัวแปรซึ่งให้ผลที่แตกต่างเช่นกันในการใช้ตรรกะ หรือให้เขียนเป็น ||(ขีดตงั้ สองตวั ติดกนั ) ถ้าเขียนเป็น | (ขีดตั้งตัวเดียว) จะหมายถึงตัวกระทาหรือระดับบิตกับตัวแปรตัวกระทา NOTระดบั บิต (~) จะแตกต่างจากตัวกลับผลให้เป็นตรงขา้ ม (!) ใหเ้ ลอื กใช้ให้ถกู ต้อง ตัวอย่างที่ 3.14 if (a >= 10 && a <= 20){} // true if a is between 10 and 20 3.5 ส่วนของตัวกระทาระดับบติ ตัวกระทาระดบั บติ จะนาบิตของตวั แปรมาประมวลผล ใชป้ ระโยชน์ในการแกป้ ัญหาดา้ นการเขียนโปรแกรมได้หลากหลายตัวกระทา ระดับของภาษา C (ซึ่งรวมถึง Arduino) มี 6 ตวั ไดแ้ ก่ & (bitwise AND) | (OR) ^ (Exclusive OR) ~ (NOT) << (เล่ือนบติ ไปทางขวา) >> (เลื่อนบติ ไปทางซ้าย) 3.5.1 ตวั กระทาระดับบิต AND (&) คาสั่ง AND ในระดับบิตของภาษา C เขียนได้โดยใช้ & หนึ่งตัวโดยต้องเขียนระหว่างนิพจน์ หรือตัวแปรที่เป็นเลขจานวนเต็ม การทางานจะนาข้อมูลแต่ละบิตของตัวแปรท้ังสองตัวมากระทาทางตรรกะและ (AND) โดยมีกฎดงั นี้ ถา้ อินพตุ ท้ังสองตวั เป็น “1” ทั้งคู่ เอาต์พตุ เป็น “1” กรณอี น่ื ๆเอาต์พตุ เป็น “0” ดังตัวอย่างต่อไปนีใ้ นการดูใหค้ ขู่ องตัวกระทาตามแนวตั้ง 0 0 1 1 Operand1 0 1 0 1 Operand2 —————————— 0 0 0 1 Returned result ใน Arduino ตวั แปรประเภท int จะมีขนาด 16 บิต ดงั นน้ั เมื่อใชต้ ัวกระทาระดบั บิต AND จะมีการกระทาหน่วยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรยี งโดยครทู ันพงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บ้ืองต้น 15ตรรกะและพร้อมกนั กับขอ้ มูลท้ัง 16 บติ ดังตัวอยา่ งในส่วนของโปรแกรมต่อไปนี้ ตัวอยา่ งท่ี 3.15 int a = 92; // in binary: 0000000001011100 int b = 101; // in binary: 0000000001100101 int c = a & b; // result: 0000000001000100 // or 68 in decimal. ในตัวอย่างนี้จะนาข้อมูลทั้ง 16 บิตของตัวแปร a และ b มากระทาทางตรรกะ AND แล้วนาผลลัพธ์ท่ีได้ท้งั 16 บติ ไปเกบ็ ทีต่ ัวแปร c ซ่งึ ไดค้ า่ เป็น 01000100 ในเลขฐานสองหรือเท่ากับ 68 ฐานสิบ นยิ มใช้ตวั กระทาระดับบิต AND เพื่อเลือกขอ้ มลู บิตท่ีต้องการ (อาจเป็นหน่ึงบิตหรือหลายบิต) จากตัวแปรint ซึง่ การเลอื กเพยี งบางบิตน้ีจะเรียกวา่ masking 3.5.2 ตวั กระทาระดบั บิต OR (|) คาส่ังระดับบิต OR ของภาษา C เขียนได้โดยใช้เคร่ืองหมาย | หนึ่งตัว โดยต้องเขียนระหว่างนิพจน์ หรือตัวแปรท่ีเป็นเลขจานวนเต็ม การทางานจะนาข้อมูลแต่ละบิตของตัวแปรท้ังสองตัวมากระทาทางตรรกะหรือ (OR) โดยมีกฎดังนี้ ถ้าอินพุตตัวใดตัวหนึ่งหรือทั้งสองตัวเป็น “1” เอาต์พุตเป็น “1” กรณีท่ีอินพุตเป็น “0”ทั้งคู่เอาต์พตุ จึงจะเป็น “0” ดังตวั อย่างต่อไปน้ี 0 0 1 1 Operand1 0 1 0 1 Operand2 —————————— 0 1 1 1 Returned result ตัวอย่างท่ี 3.16 ส่วนของโปรแกรมแสดงการใชต้ ัวกระทาระดบั บิต OR int a = 92; // in binary: 0000000001011100 int b = 101; // in binary: 0000000001100101 int c = a | b; // result: 0000000001111101 // or 125 in decimal. ตัวอย่างที่ 3.17 โปรแกรมแสดงการใช้ตัวกระทาระดับบิต AND และ OR ตัวอย่างงานที่ใช้ตัวกระทาระดับบิต AND และOR เป็นงานที่โปรแกรมเมอร์เรียกว่า Read-Modify-Write on a port สาหรับไมโครคอนโทรลเลอร์ 8 บิต ค่าท่ีอ่านหรือเขียนไปยังพอร์ตมีขนาด 8 บิต ซึ่งแสดงค่าอินพุตท่ีขาทั้ง 8 ขา การเขียนค่าไปยังพอร์ตจะเขียนค่าคร้ังเดยี วได้ท้ัง 8 บิต ตัวแปรช่ือ PORTD เปน็ คา่ ที่ใช้แทนสถานะของขาดิจิตอลหมายเลข 0,1,2,3,4,5,6,7 ถา้ บิตใดมีค่าเป็น1 ทาให้ขานั้นมีค่าลอจิกเป็น HIGH ต้องกาหนดให้ขาพอร์ตนั้นๆทางานเป็นเอาต์พุตด้วยคาสั่ง pinMode()หนว่ ยที่ 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรยี งโดยครูทนั พงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบื้องตน้ 16ดงั นนั้ ถ้ากาหนดค่าให้ PORTD = B00110001 ก็คือต้องการให้ขา 2, 3 และ 7 เป็น HIGH ในกรณีนี้ไม่ต้องเปลี่ยนคา่ สถานะของขา 0 และ 1 ซ่งึ ปกติแลว้ ฮารด์ แวร์ของ Arduino ใช้ในการสื่อสารแบบอนุกรม ถ้าไปเปล่ียนค่าแล้วจะกระทบต่อการสอ่ื สารแบบอนุกรม อัลกอรธิ ึมสาหรบั โปรแกรมเป็นดังนี้ อ่านค่าจาก PORTD แล้วลา้ งคา่ เฉพาะบติ ท่ตี ้องการควบคุม (ใช้ตวั กระทาแบบบิต AND) นาคา่ PORTD ทแี่ กไ้ ขจากข้างตน้ มารวมกบั คา่ บติ ท่ตี อ้ งการควบคมุ (ใชต้ ัวกระทาแบบบิต OR) ซึ่งเขียนเป็นโปรแกรมได้ ดังน้ี int i; // counter variable int j; void setup() { DDRD = DDRD | B11111100; // set direction bits for pins 2 to 7, // leave 0 and 1 untouched (xx | 00 == xx) // same as pinMode(pin,OUTPUT) for pins 2 to 7 Serial.begin(9600); } void loop() { for (i=0; i<64; i++) { PORTD = PORTD & B00000011; // clear out bits 2 - 7, leave pins 0 // and 1 untouched (xx & 11 == xx) j = (i << 2); // shift variable up to pins 2 - 7 // to avoid pins 0 and 1 PORTD = PORTD | j; // combine the port information with // the new information for LED pins Serial.println(PORTD, BIN); // debug to show maskingหนว่ ยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครทู ันพงษ์ ภ่รู ักษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบือ้ งตน้ 17 delay(100); }}3.5.3 คาสงั่ ระดับบิต Exclusive OR (^)เปน็ โอเปอร์เตอร์พิเศษที่ไม่ค่อยได้ใช้ในภาษา C/C++ ตัวกระทาระดับบิต exclusive OR (หรือ XOR) จะเขยี นโดยใชส้ ัญลักษณ์เครื่องหมาย ^ ตัวกระทานี้มีการทางานใกล้เคียงกับตัวกระทาระดับบิต OR แต่ต่างกันเมื่ออินพุตเปน็ “1” ทงั้ คจู่ ะใหเ้ อาตพ์ ุตเปน็ “0” แสดงการทางานได้ดังน้ี0011 Operand10101 Operand2________0110 Returned resultหรือกล่าวได้อีกอย่างวา่ ตัวกระทาระดับบติ XOR จะให้เอาต์พุตเป็น “0” เมื่ออินพุตทั้งสองตัวมีค่าเหมอื นกนั และใหเ้ อาต์พุตเปน็ “1” เม่ืออินพตุ ท้งั สองมคี ่าต่างกันตวั อยา่ งท่ี 3.18int x = 12; / / binary: 1100int y = 10; / / binary: 1010int z = x ^ y; / / binary: 0110, or decimal 6ตัวกระทาระดับบิต XOR จะใช้มากในการสลับค่าบางบิตของตัวตัวแปร int เช่นกลับจาก “0” เป็น “1”หรือกลบั จาก”1” เปน็ “0”เม่ือใช้ตัวกระทาระดับบิต XOR ถ้าบิตของ mask เป็น “1” ทาให้บิตน้ันถูกสลับค่า ถ้า mask มีค่าเป็น“1” บิตน้นั มคี า่ คงเดิม ตัวอย่างต่อไปนเี้ ป็นโปรแกรมแสดงการสั่งใหข้ าดดิจิตอล 5(Di5) มกี ารกลบั ลอจกิ ตลอดเวลาตวั อยา่ งท่ี 3.19/ / Blink_Pin_5/ / demo for Exclusive ORvoid setup ( ){DDRD = DDRD I B00100000;/ / set digital pin five as OUTPUTSerial. begin (9600);}void loop (){PORTD = PORTD ^ B00100000;หนว่ ยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทนั พงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บ้อื งตน้ 18 / / invert bit 5 (digital pin 5), / / leave others untouched delay (100); } 3.5.4 ตัวกระทาระดับบิต NOT (~) ตวั กระทาระดบั บิต NOT จะเขียนโดยใช้สัญลักษณ์เครื่องหมาย ~ ตัวกระทานี้จะใช้กับตัวถูกกระทาเพียงตัวเดียวที่อยู่ขวามือ โดยการสลับบิตทุกบิตให้มีค่าตรงกันข้ามคือ จาก ”0” “1” และจาก “1” เป็น “0” ดังตัวอยา่ ง 0 1 Operand1 ____ 1 0 ~ Operand1 int a = 103; / / binary: 0000000001100111 int b = ~a; / / binary: 1111111110011000 เมอื่ กระทาแลว้ ทาให้ตวั แปร b มคี ่า -104 (ฐานสบิ ) ซง่ึ คาตอบทไ่ี ดต้ ิดลบ เนอ่ื งจากบติ ท่ีมคี วามสาคัญสูงสุด(บิตซา้ ยมอื สุด) ของตัวแปร int อนั เปน็ บติ แจ้งวา่ ตัวเลขเปน็ บวกหรือลบ มีค่าเปน็ “1” แสดงว่าค่าที่ได้น้ีติดลบ โดยในคอนโทรลเลอร์จะเก็บค่าตวั เลขทั้งบวกและลบ ตามระบบทูคอมพลีเมนต์ (2’s complement) การกระทาประกาศตัวแปร int ซึ่งมีความหมายเหมือนกับการประกาศตัวแปรเป็น signed int ต้องระวังค่าของตัวแปรจะตดิ ลบได้ 3.5.5 คาสงั่ เล่ือนบิตไปทางซา้ ย (<<) และเลื่อนบิตไปทางขวา (>>) ในภาษา C/C++ มตี ัวกระทาเล่ือนบติ ไปทางซ้าย << 3.6 ไวยากรณ์ภาษา C / C++ ของ Arduino 3.6.1 เซมโิ คลอน – semicolon ; ใชเ้ ขียนแจ้งว่าจบคาส่งั ตวั อยา่ ง 3.23 int a = 13; บรรทัดคาส่งั ที่ลมื เขยี นปดิ ท้ายดว้ ยเซมโิ คลอน จะทาให้แปลโปรแกรมไมผ่ ่าน โดยตัวแปรภาษาอาจจะแจ้งใหท้ ราบวา่ ไมพ่ บเครือ่ งหมายเซมโิ คลอน หรือแจ้งเป็นการผิดพลาดอื่นๆ บางกรณีท่ีตรวจสอบบรรทัดท่ีแจ้งว่าเกิดการผิดพลาดแลว้ ไม่พบทีผ่ ดิ ใหต้ รวจสอบบรรทดั กอ่ นหน้านั้น 3.6.2 วงเล็บปีกกา – curly brace { } เครือ่ งหมายวงเล็บปีกา เปน็ สว่ นสาคญของภาษาซี โดยมกี ารใชง้ านตา่ งตาแหน่ง สร้างความสับสนให้กับผูที่เร่ิมต้นวงเล็บปีกกาเปิด { จะต้องเขียนตามด้วยวงเล็บปีกกาปิด } ด้วยเสมอ หรือท่ีเรียกว่าวงเล็บต้องครบคู่หนว่ ยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครทู นั พงษ์ ภูร่ ักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บือ้ งต้น 19ในซอฟต์แวร์ Arduino IDE ท่ีใช้เขียนโปรแกรมจะมีความสามารถในการตรวจสอบการควบคู่ของเคร่ืองหมายวงเล็บผู้ใช้งานเพย่ี งแค่คลกิ ท่ีวงเลบ็ จะแสดงวงเลบ็ ท่ีเหลือ สาหรับโปรแกรมเมอรม์ อื ใหม่ และโปรแกรมเมอร์ท่ียา้ ยจากภาษา BASIC เปน็ ภาษา C มักจะสับสนกับการใชเ้ คร่ืองหมายวงเล็บ แทท้ ีจ่ ริงแลว้ เครื่องหมายปกี กาปดิ นีเ้ ที่ยบไดก้ บั คาสั่ง RETURN ของ Subroutine (function)หรือแทนคาสงั่ ENDIF ในการเปรียบเทียบ และแทนคาสัง่ NEXT ของคาสั่งวนรอบ FOR เน่อื งจากมีการใชว้ งเล็บปีกกาไดห้ ลากหลาย ดังน้นั เม่อื ต้องการเขียนคาส่ังท่ีต้องใช้เคร่ืองหมายวงเล็บ เมื่อเขยี นวงเล็บเปิดแลว้ ใหเ้ ขียนเคร่ืองหมายวงเล็บปดิ ทนั ที ถัดมาจึงค่อยเคาะปุ่ม Enter ในระหว่างเคร่ืองหมายวงเล็บเพอื่ ขึ้นบรรทดั ใหม่ แล้วเขียนคาส่ังท่ตี อ้ งการ ถา้ ทาไดต้ ามนีว้ งเลบ็ จะครบค่แู นน่ อน สาหรับวงเล็บทไ่ี มค่ รบค่ทู าให้เกดิ ผิดพลาดตอนคอมไฟลโ์ ปรแกรม ถ้าเป็นโปรแกรมขนาดใหญ่จะหาท่ีผิดได้ยาก ตาแหนง่ ทอี่ ย่ขู องเครื่องหมายวงงเล็บแต่ละตัวจะมีผลอย่างมากต่อไวยากรณ์ของภาษาคอมพิวเตอร์ การย้ายตาแหนง่ วงเล็บไปเพียงหนึ่งหรอื สองบรรทดั ทาให้ตวั โปรแกรมทางานผิดไป ตาแหน่งที่ใชว้ งเล็บปีกกา ฟงั ก์ชน้ั (function) void myfunction (datatype argument) { statements (s) } คาสงั่ วนรอบ (loops) while (boolean expression) { statement (s) } do { statement (s) } while (boolean expression); for (initialisation; termination condition; incrementing expr) { statement (s) }หน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทันพงษ์ ภรู่ ักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้อื งต้น 20 คาสั่งทดสอบเงื่อนไข (condition) If (boolean expression) { statement (s) } else if (boolean expression) { statement (s) } else { statement (s) } 3.6.3 หมายเหตบุ รรทดั เดียวและหลายบรรทดั / / และ / * . . . */ เป็นส่วนของโปรแกรมท่ีผู้ใช้เขียนเพ่ืมเติมว่าโปรแกรมทางานอย่างไร โดยส่วนท่ีเป็นหมายเหตุจะไม่ถูกคอมไพล์ ไม่นาไปประมวลผล มีประโยชน์มากสาหรับการตรวจสอบโปรแกรมภายหลังหรือใช้แจ้งให้เพ่ือนร่วมงานหรอื บุคคลอนื่ ทราบว่าบรรทดั น้ีใชท้ าอะไร ตัวหมายเหตุภาษา C มี 2 ประเภทคือ (1) หมายเหตบุ รรทดั เดียว เขียนเครื่องสเลช // 2 ตวั หนา้ บรรทัด (2) หมายเหตุหลายบรรทัด เขียนเคร่ืองหมายสเลช / คู้กับดอกจัน * คร่อมข้อความที่เป็นหมายเหตุ เช่น /* blabla */ 3.6.4 # define เป็นคาสั่งที่ใช้งานมาก ในการกาหนดค่าคงที่ให้กับโปรแกรม ในการกาหนดค่าคงท่ีไม่ได้เปลืองพื้นที่หน่วยความจาของไมโครคอนโทรลเลอร์แต่อย่างไร เม่ือถึงข้ึนตอนแปลภาษา คอมไพเลอร์จะแทนที่ตัวอักษรข้อความดว้ ยคา่ ทก่ี าหนดไว้ ใน Arduino จะใช้คาสงั่ # define ตรงกับภาษา C รูปแบบ # define constantName value อย่าลืมเครอื่ งหมาย # ตวั อย่างท่ี 3-24 # define ledpin 3 เป็นการกาหนดใหต้ ัวแปร ledpin เทา่ กับค่าคงที่ 3หน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครทู ันพงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บื้องตน้ 21 เทคนดิ สาหรบั การเขยี นโปรแกรม ท้ายคาส่ัง # define ไม่ต้องมีเคร่ืองหมายเซมิโคลอน ถ้าใส่เกินแล้วเวลาคอมไพล์โปรแกรมจะแจ้งว่าเกิดการผิดพลาดในบรรทดั ถดั ไป 3.6.5. # include ใช้สงั่ ให้รวมไฟลอ์ นื่ ๆ เขา้ กบั ไฟล์โปรแกรมหลกั กอ่ น แล้วจึงทาการคอมไพล์โปรแกรม รูปแบบคาสั่ง # include <file> # include “file” ตัวอย่างที่ 3.25 # include <stdio.h> # include “lcd.h” บรรทัดแรกจะส่ังให้เรียกไฟล์ stdio.h มารวมกับไฟล์โปรแกรมหลัก โดยค้นหาไฟล์จากตาแหน่งที่เก็บไฟล์ระบบของ Arduino โดยปกติเปน็ ไฟล์มาตรฐานทีม่ าพรอ้ มกบั Arduino บรรทัดท่ี 2 สั่งให้รวมไฟล์ lcd.h มารวมกับไฟล์โปรแกรมหลัก โดยหาไฟล์จากตาแหน่งของไฟล์ภาษา Cปกตเิ ปน็ ไฟลท์ ผ่ี ใู้ ชส้ รา้ งขึน้ เอง ในการแก้ไขโปรแกรมใน Arduino มีขอ้ แนะนาวา่ อยา่ แกไ้ ขบรรทดั นั้นทนั ที ใหท้ าบรรทดั นั้นเป็นหมายเหตุกอ่ นแลว้ จึงแกโ้ ปรแกรมในบรรทดั นั้น 3.7 ตัวแปร ตัวแปรเป็นตัวอักษรหลายตัวๆ ท่ีกาหนดขึ้นในโปรแกรมเพ่ือใช้ในการเก็บค่าข้อมูลต่างๆเช่น ค่าท่ีอ่านได้จากตัวตรวจจับ ทต่ี ่ออยู่กบั ขาพอรต์ แอนะลอ็ กของ Arduino ตัวแปรมีหลายประเภทดงั นี้ 3.7.1 char : ตัวแปรประเภทตวั อักขระ เปน็ ตัวแปรที่มีขนาด 1 ไบต์ (8 บิต) มีไว้เพ่ือเก็บค่าตัวอักษร ตัวอักษรในภาษาซีจะเขียนอยู่ใเคร่ืองหมายคาพูดขดี เดยี วเชน่ ‘A’ (สาหรับข้อความท่ีประกอบจากตัวอักษรหลายตัวเขียนต่อกันจะเขียนอยู่ในเครื่องหมายคาพูดปกติเชน่ “ABC”) สามารถส่งั กระทาทางคณติ ศาสตร์กับตัวอักษรได้ในกรณีจะนาค่ารหัส ASCII ของตัวอักษรมาใช้เชน่ ‘A’ +1 มีคา่ เทา่ กับ 66 เนอื่ งจากคา่ รหสั ASCII ของตวั อักษร A เท่ากบั 65 รูปแบบคาสง่ั charsign = ' '; พารามเิ ตอร์ char var = ‘x’; var คอื ชอ่ื ของตวั แปรประเภท char ที่ต้องการ x คอื ค่าทีต่ อ้ งการกาหนดให้กับตวั แปร ในท่ีน้ีเปน็ ตวั อักษรหนึ่งตัวหนว่ ยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรียงโดยครูทันพงษ์ ภูร่ กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบอื้ งต้น 22 3.7.2 byte : ตัวแปรประเภทตัวเลข 8 บติ หรือ 1 ไบต์ ตัวแปร byte ใช้เก็บคา่ ตวั เลขขนาด 8 บติ มีค่าได้จาก 0 - 255 ตวั อย่างที่ 3.26 byte b = B10010111; // “B” is the binary formatter (151 decimal) 3.7.3 int : ตัวแปรประเภทตัวเลขจานวนเต็ม ย่อจาก interger ซึ่งแปลว่าเลขจานวนเต็ม int เป็นตัวแปรพื้นฐานสาหรับเก็บตัวเลข ตัวแปรหนึ่งตัวมีขนาด 2 ไบต์เก็บค่าได้จาก -32,768 ถึ ง 32,767 ในการเก็บค่าตัวเลขติดลบ จะใช้เทคนิคท่ีเรียกว่าทูคอพลีเมนต์(2’s complement) บิตสูงสดุ บางทจี ะเรยี กว่าเปน็ บติ เครอ่ื งหมายหรือ sign bit ถ้ามคี า่ เป็น “1” แสดงว่าค่าติดลบใน Arduino จะจัดการกับตัวเลขค่าติดลบใหเ้ อง ทาใหน้ าค่าตัวแปรไปคานวณได้อย่างถูกต้อง อย่างไรก็ตามเม่ือนาตวั เลขค่าติดลบนไี้ ปเลื่อนบิตไปทางขวา (>>) จะมีปัญหาเรื่องค่าของตวั เลขท่ีผิดพลาด รูปแบบคาสัง่ int var = val; พารามิเตอร์ var คือชอื่ ของตัวแปรประเภท int ท่ีตอ้ งการ val คอื คา่ ทต่ี ้องการกาหนดใหก้ บั ตวั แปร ตัวอย่างที่ 3.27 int ledPin = 31; เทคนคิ สาหรับการเขียนโปรแกรม เมื่อตัวแปรมีค่ามากกว่าค่าสูงสุดท่ีเก็บได้ จะเกิดการ “ล้นกลับ” (Roll Over) ไปยังค่าต่าสุดท่ีเก็บได้และเมอ่ื มคี ่าน้อยกวา่ ค่าต่าสุดท่ีเก็บได้ จะลน้ กลบั ไปยงั คา่ สงู สุด ดงั ตัวอยา่ งตอ่ ไปนี้ ตัวอย่างท่ี 3.28 int x x = -32,768; x = x - 1; // x now contains 32,767 // - rolls over in neg. direction x = 32,767; x = x + 1; // x now contains -32,768 - rolls over 3.7.4 unsigned int : ตัวแปรประเภทเลขจานวนเต็มไม่คดิ เครื่องหมาย ตวั แปรประเภทน้ีคลา้ ยกับตัวแปร int ตรงท่ีใชห้ นว่ ยความจา 2 ไบต์ แตจ่ ะเก็บเลขจานวนเต็มบวกโดยเก็บค่า 0 ถงึ 65,535 รปู แบบคาสงั่ unsigned int var = val;หน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรียงโดยครูทันพงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บือ้ งต้น 23 พารามิเตอร์ var คือช่อื ของตวั แปร int ทต่ี อ้ งการ val คือคา่ ที่ตอ้ งการกาหนดใหก้ ับตัวแปร ตัวอย่างท่ี 3.29 unsigned int ledPin = 31; เทคนิคสาหรบั การเขียนโปรแกรม เมื่อตัวแปรมีค่ามากกว่าค่าสูงสุดจะล้นกลับไปค่าต่าสุด และเม่ือมีค่าน้อยกว่าค่าต่าสุดจะล้นกลับเป็นค่าสงู สุด ดงั ตัวอยา่ ง ตวั อยา่ งที่ 3.30 unsigned int x x = 0; x = x - 1; // x now contains 65535 // - rolls over in neg direction x = x + 1; // x now contains 0 - rolls over 3.7.5 long : ตัวแปรประเภทเลขจานวนเต็ม 32 บิต เปน็ ตัวแปรเกบ็ ค่าเลขจานวนเต็ม ทขี่ ยายความจุเพ่มิ จากตัวแปร int โดยตวั แปร long หน่งึ ตัวกินพื้นที่หน่วยความจา 32 บิต (4 ไบต์) เก็บค่าได้จาก -2,147,483,648 ถึง 2,147,483,647 รูปแบบคาสั่ง long var = val; พารามิเตอร์ var คอื ชอ่ื ของตวั แปร long ท่ตี อ้ งการ val คอื ค่าทต่ี อ้ งการกาหนดใหก้ ับตวั แปร ตวั อย่างท่ี 3.31 long time; void setup() { Serial.begin(9600); } void loop() { Serial.print(\"Time: \"); time = millis();หนว่ ยที่ 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรียงโดยครทู นั พงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบือ้ งตน้ 24 Serial.println(time); //prints time since program started delay(1000); // wait a second so as not to send massive amounts of data } 3.7.6 unsigned long : ตัวแปรประเภทเลขจานวนเต็ม 32 บิต แบบไม่คิดเครอื่ งหมาย เป็นตัวแปรเก็บค่าเลขจานวนเต็มบวก ตัวแปรหนึ่งตัวกินพื้นที่หน่วยความจา 32 บิต (4 ไบต์) เก็บค่าได้จาก 0 ถึ ง 4,294,967,295 รปู แบบคาสั่ง unsigned long var = val; พารามเิ ตอร์ var คือช่ือของตวั แปร unsigned long ทีต่ อ้ งการ val คอื คา่ ทตี่ ้องการกาหนดใหก้ บั ตวั แปร ตวั อยา่ งท่ี 3.32 long time; void setup() { Serial.begin(9600); } void loop() { Serial.print(\"Time: \"); time = millis(); Serial.println(time); //prints time since program started delay(1000); // wait a second so as not to send massive amounts of data } 3.7.7 float : ตวั แปรประเภทเลขทศนิยม เป็นตัวแปรสาหรับเก็บค่าเลขทศนิยม นิยมใช้เก็บค่าสัญญาณแอนะล็อกหรือค่าที่ต่อเนื่อง ตัวแปรแบบน้ีเก็บค่าได้ละเอียดกว่าตัวแปร int โดยเก็บค่าได้ในช่วง 3.4028235 x 1038 ถึ ง -3.4028235 x 1038 ตัวแปรหนึ่งตัวจะใช้พ้ืนที่หน่วยความจา 32 บิต (4 ไบต์) ในการคานวณคณิตศาสตร์กับตัวแปร float จะช้ากว่าการคานวณของตวั แปร int ดังน้ันพยายามหลีกเล่ียงการคานวณกับตัวแปร float เช่นในคาสั่งวนรอบท่ีทางานด้วยความเรว็ สงู สดุ สาหรับฟังก์ชันทางเวลาที่ต้องแม่นยาอย่างมาก โปรแกรมเมอร์บางคนจะทาการแปลงตัวเลขทศนิยมให้เป็นเลขจานวนเต็มก่อน แล้วจึงคานวณเพ่ือให้ทางานได้เร็วข้ึน จะเห็นได้ว่าการคานวณคณิตศาสตร์ของเลขหนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรยี งโดยครทู นั พงษ์ ภ่รู ักษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบ้อื งตน้ 25floating point จะมีการใช้งานมากสาหรับการคานวณค่าข้อมูลที่รับจากภายนอกเป็นตัวเลขทศนิยม ซึ่งทางผู้ศกึ ษาระบบไมโครคอนโทรลเลอรม์ ักจะมองข้ามไป รปู แบบคาสงั่ float var = val; พารามิเตอร์ var คอื ชอ่ื ของตวั แปร float ท่ตี อ้ งการ val คอื ค่าท่ีตอ้ งการกาหนดให้กบั ตวั แปร ตัวอย่างที่ 3.33 float myfloat; float sensorCalbrate = 1.117; ตัวอย่างที่ 3.34 int x; int y; float z; x = 1; y = x / 2; // y now contains 0, // integers can’t hold fractions z = (float)x / 2.0; // z now contains .5 // (you have to use 2.0, not 2) ในฟังก์ช่ัน serial.println() ของการส่งค่าตัวแปรไปยังพอร์ตอนุกรม จะตัดตัวเลขเศษทศนิยมออกให้เหลือเป็นเลขจานวนเตม็ ถา้ ตอ้ งการเพ่มิ ความละเอียดใหน้ าคา่ ตวั แปรคูณดว้ ย 10 ยกกาลงั ตา่ งๆตามที่ต้องการ 3.7.8 double : ตวั แปรประเภทเลขทศนิยมความละเอยี ดสองเท่า เป็นตัวแปรทศนิยมความละเอียดสองเท่า มีขนาด 8 ไบต์ ค่าสูงสุดที่เก็บได้คือ 1.7976931348623157 x10308 ใน Arduino มหี น่วยความจาขนาดจากดั จึงไม่นิยมใช้ตวั แปรประเภทนี้ 3.7.9 string : ตัวแปรประเภทข้อความ เป็นตัวแปรเกบ็ ขอ้ ความ ซง่ึ ในภาษา C จะนิยามเปน็ อะเรยข์ องตวั แปรประเภท char ตัวอย่างท่ี 3.35 ตัวอยา่ งการประกาศตวั แปรสตริง char Str1[15]; char Str2[8] = {‘a’,‘r’,‘d’,‘u’,‘i’,‘n’,‘o’}; char Str3[8] = {‘a’,‘r’,‘d’,‘u’,‘i’,‘n’, ‘o’,’\0'}; char Str4[ ] = “arduino”;หนว่ ยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครทู นั พงษ์ ภ่รู ักษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบือ้ งตน้ 26 char Str5[8] = “arduino”; char Str6[15] = “arduino”; Str1 เปน็ การประกาศตัวแปรสตรงิ โดยไม่ได้กาหนดค่าเรม่ิ ต้น Str2 ประกาศตัวแปรสตรงิ พรอ้ มกาหนดค่าให้กับขอ้ ความทลี ะตวั อักษร จากตวั อย่างคอมไพเลอร์จะเพ่ิม null character ใหเ้ อง Str3 ประกาศตัวแปรสตรงิ พรอ้ มกาหนดคา่ ให้กับข้อความทลี ะตัวอักษร จากตวั อย่างเพิ่มคา่ nullString เอง Str4 ประกาศตวั แปรสตริงคพ์ ร้อมกาหนคค่าตัวแปรในเครื่องหมายคาพูด จากตัวอย่างไมไ่ ด้กาหนดขนาดตวั แปรคอมไพเลอร์ จะกาหนดขนาดให้เองตามจานวนตวั อักษร + 1 สาหรับ null string Str5 ประกาศตวั แปรสตริงพร้อมกาหนดตัวแปรในเครือ่ งหมายคาพดู จากตัวอยา่ งต้องกาหนดขนาดตัวแปรเอง Str6 ประกาศตวั แปรสตริง โดยกาหนดขนาดเผอ่ื ไวส้ าหรับขอ้ ความอนื่ ทยี่ าวมากกวา่ นี้ 3.7.10 การเพ่ิมตวั อักษรแจง้ ว่าจบขอ้ ความ (null termination) ในตัวแปรสตริงของภาษาซี กาหนดให้ตัวอักษรสุดท้ายเป็นตัวแจ้งการจบข้อความ (null string) ซ่ึงก็คือตัวอักษร \0 ในการกาหนดขนาดของตัวแปร (ค่าในวงเล็บเหลี่ยม) จะต้องกาหนดให้เท่ากับจานวนตัวอักษร+ 1ดงั ในตัวแปร Str2 และ Str3 ในตัวอย่างที่ 3.35 ที่ข้อความ Arduino มีตัวอักษร 7 ตัว ในการประกาศตัวแปรต้องระบเุ ป็น [8] ในการประกาศตัวแปรสตรงิ ตอ้ งเผอ่ื พนื้ ทีส่ าหรับเก็บตัวอักษรแจ้งว่าจบข้อความ มิฉะน้ันคอมไพเลอร์จะแจ้งเตือนว่าเกดิ การผิดพลาด ในตัวอยา่ งที่ 3.35 ตวั แปร Str1 และ Str6 เกบ็ ข้อความได้สงู สดุ 14 ตัวอักษร 3.7.11 เคร่อื งหมายคาพูดขีดเดียวและสองขีด ปกติแล้วจะกาหนดค่าตัวแปรสตริงภายในเครื่องหมายคาพูด เช่น \"Abc\" สาหรับตัวแปรตัวอักษร (char)จะกาหนดคา่ ภายในเครือ่ งหมายคาพูดขดี เดยี ว 'A' 3.7.12 ตัวแปรอะเรย์ (array) ตัวแปรอะเรย์เป็นตัวแปรหลายตัว ท่ีถูกเก็บรวมอยู่ในตัวแปรช่ือเดียวกัน โดยอ้างถึงตัวแปรแต่ละตัวด้วยหมายเลขดัชนีท่ีเขียนอยู่ในวงเล็บสีเ่ หลย่ี ม ตวั แปรอะเรย์ของ Arduino จะอ้างองิ ตามภาษา C ตัวแปรอะเรย์อาจจะซับซอ้ น แต่ใชแ้ คต่ ัวแปรอะเรย์อยา่ งงา่ ยจะตรงไปตรงมา ตัวอยา่ งการประกาศตวั แปรอะเรย์ int myInts [6]; int myPins [ ] = {2, 4, 8, 3, 6}; int mySensVals [6] = {2, 4, -8, 3, 2}; char message [6] = “hello”; เราสามารถประกาศตัวแปรอะเรยไ์ ด้โดยยงั ไม่กาหนดค่าดังตวั แปร myInts ในตวั แปร myPins จะประกาศตวั แปรอะเรย์โดยไมร่ ะบขุ นาด ซงึ่ ทาไดเ้ ม่อื ประกาศตวั แปรแลว้ กาหนดค่าทันที เพื่อให้คอมไพเลอร์นับว่า ตัวแปรมีหน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรียงโดยครทู นั พงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบอื้ งตน้ 27สมาชกิ กีต่ วั และกาหนดคา่ ไดถ้ ูกตอ้ ง ท้ายท่ีสุดสามารถประกาศตัวแปรและกาหนดขนาดของตัวแปรอะเรย์ดังตัวแปร mySersVals ในการประกาศอะเรยข์ องตวั แปร char จะตอ้ งเผอื่ ทสี่ าหรับเก็บคา่ ตัวอักษรแจ้งวา่ จบขอ้ ความดว้ ย การใชง้ านตัวแปรอะเรย์ การใช้งานตัวแปรอะเรย์ทาได้โดยการพิมพ์ช่ือตัวแปร พร้อมกับระบุค่าดัชนีภายในเครื่องหมายวงเล็บส่เี หลย่ี ม คา่ ดชั นขี องตัวแปรอะเรยเ์ ร่ิมต้นด้วยค่า 0 ดงั นั้นคา่ ของตวั แปร mySensVals มีคา่ ดังน้ี mySensVals [0] == 2, mySensVals [1] == 4, ฯลฯ การกาหนดคา่ ให้กบั ตัวแปรอะเรย์ mySensVals [0] = 10; การเรียกคา่ สมาชิกของตัวแปรอะเรย์ x = mySensVals [4]; เทคนคิ การเขียนโปรแกรมเกย่ี วกับตัวแปรอะเรย์ ในการเรียกใช้ค่าสมาชกิ ของตัวแปรอะเรย์ ตอ้ งระวังอย่าอ้างถึงค่าในวงเลบ็ ท่ีเกินที่กาหนด เช่นประกาศตัวแปร int x [3] ตัวแปรมี 3 ตัว คือ x [0], x [1] และ x [2] ถ้าอ้างถึง x [3] จะเป็นการอ่านค่าจากหน่วยความจาซ่ึงกาหนดไว้ใช้งานอยา่ งอ่นื ค่าทอี่ า่ นได้จะผดิ พลาด การเขียนค่าให้กับตัวแปรอะเรย์ตัวท่ีเกินกว่ากาหนดไว้ อาจทาให้โปรแกรมแฮงค์ (หยุดการทางาน) หรือทางานผิดเพยี้ นไป การอ่านหรอื เขยี นค่าเกนิ คา่ ดัชนีของตวั แปรอะเรย์น้ี ทาใหเ้ กดิ บกั (ข้อผิดพลาด) ทย่ี ากตอ่ การคน้ หา อะเรย์และคาสงั่ วนรอบ for โดยทัว่ ไปเราจะพบการใชง้ านตัวแปรอะเรย์ภายในคาสัง่ for โดยใชค้ ่าตวั แปรนบั รอบคาส่ัง for เป็นค่าดัชนีของตัวแปรอะเรย์ ดังตัวอย่างการพิมพ์ค่าสมาชิกแต่ละตัวของตัวแปรอะเรย์ผ่านพอร์ตอนุกรม ให้เขียนโปรแกรมดงั น้ี int i; for (i = 0; I < 5; I = I + 1) { Serial.println (myPins [i] ); } ตวั อย่างโปรแกรมสาธิตการใช้งานตัวแปรอะเรย์ที่สมบูรณ์ ดูได้ในตัวอย่างในหัวข้อ Tutorials ในเว็บไซต์www.arduino.ccหน่วยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรียงโดยครูทันพงษ์ ภ่รู กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บ้ืองต้น 28 3.8 ขอบเขตของตัวแปร ตัวแปรในภาษ C ที่ใช้ใน Arduino จะมีคุณสมบัติท่ีเรียกว่า “ขอบเขตของตัวแปร” (scope) ซึ่งแตกต่างจากภาษา BASIC ซ่งึ ตวั แปรทุกตัวมสี ถานะเทา่ เทยี มกันหมดคือ เปน็ แบบ global 3.8.1 ตัวแปรโลคอลและโกลบอล ตวั แปรแบบโกลบอล (global variable) เป็นตัวแปรท่ที ุกฟงั กช์ น่ั ในโปรแกรมรจู้ ัก โดยตอ้ งประกาศตัวแปรนอกฟังก์ชั่น สาหรับตัวแปรแบบโลคอลหรือตัวแปรท้องถิ่น เป็นตัวแปรที่ประกาศตัวแปรอยู่ภายในเคร่ืองหมายวงเลบ็ ปีกกาของฟังก์ชัน่ และรูจ้ กั เฉพาะแค่ภายในฟังก์ชัน่ นัน้ เมอ่ื โปรแกรมเร่ิมมีขนาดใหญ่และซับซ้อนมากข้ึน การใช้ตัวแปร โลคอลจะมีประโยชน์มาก เน่ืองจากแน่ใจได้ว่ามีแค่ฟังก์ชน่ั น้ันเท่านน้ั ท่สี ามารถใช้งานตัวแปร ช่วยป้องกันการเกิดการผิดพลาดเม่ือฟังก์ช่ันทาการแก้ไขค่าตัวแปรที่ใช้งานโดยฟังก์ชนั่ อืน่ ตัวอยา่ งท่ี 3.36 int PWMval; // any function will see this variable void setup () { // … } void loop () { int i; // “I” is only “visible” inside of “loop” float f; // “f” is only “visible” inside of “loop” } 3.8.2 ตวั แปรสแตตกิ (static) เป็นคาสงวน (Keyword) ทใ่ี ช้ตอนประกาศตวั แปรทมี่ ีขอบเขตใช้งานแค่ภายในฟงั ก์ชั่นเท่านั้น โดยต่างจากตัวแปรโลคอลตรงที่ตัวแปรแบบโลคอลจะถูกสร้างและลบทิ้งทุกคร้ังที่เรียกใช้ฟังก์ชั่น สาหรับตัวแปร สแตติกเม่ือจบการทางานของฟังก์ช่ันค่าตัวแปรจะยังคงอยู่ (ไม่ถูกลบท้ิง) เป็นการรักษาค่าตัวแปรไว้ระหว่างการเรียกใช้งานฟังก์ชั่น ตวั แปรที่ประกาศเปน็ static จะถกู สร้างและกาหนดค่าในครั้งแรกทเี่ รยี กใช้ฟงั ก์ชั่นหน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรียงโดยครทู นั พงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้ืองตน้ 293.9 การกาหนดค่าคงทเ่ี ลขจานวนเตม็ เปน็ เลขฐานตา่ งๆ ของ Arduinoค่าคงท่ีเลขจานวนเต็มก็คือตัวเลขที่เขียนโปรแกรมของ Arduino โดยตรงเช่น 123 โดยปกติแล้วตัวเลขเหล่านจ้ี ะเป็นเลขฐานสบิ (decimal) ถา้ ตอ้ งการกาหนดเปน็ เลขฐานอ่นื จะตอ้ งใช้เครอ่ื งหมายพิเศษระบุ เชน่ฐาน ตวั อย่าง10 (decimal) 1232 (binary) B11110118 (octal) 017316 (hexadecimal) 0x7BDecimal ก็คอื เลขฐานสบิ ซ่ึงเราใช้ในชีวิตประจาวนัตัวอยา่ ง 101== 101 decimal ( (1 * 2^2) + (0 * 2^1) + 1)Binary เปน็ เลขฐานสองตวั ตัวเลขแตล่ ะหลกั เป็นไดแ้ ค่ 0 หรือ 1ตัวอยา่ ง B101 == 5 decimal ( (1 * 2^2) + (0 * 2^1) + 1)เลขฐานสองจะใช้งานไดไ้ ม่เกิน 8 บิต (ไมเ่ กนิ 1 ไบต์) มคี ่าจาก 0 (B0) ถึง 255 (B11111111)ถา้ ตอ้ งการป้อนเลขฐานสองขนาด 16 บิต (ตัวแปรประเภท int) จะตอ้ งป้อนคา่ สองขั้นตอนดังน้ีmyInt = (B11001100 * 256) +B10101010; // B11001100 is the high byteOctal เป็นเลขฐานแปด ตวั เลขแตล่ ะหลกั มีคา่ จาก 0 ถึง 7 เท่าน้ันตัวอย่าง 0101 == 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)ข้อควรระวังในการกาหนดค่าคงท่ี อย่าใส่เลข 0 นาหน้า มิฉะนั้นตัวคอมไพเลอร์จะแปลความหมายผดิ ไปว่าตัวเลขเป็นเลขฐาน 8Hexadecimal (hex) เปน็ เลขฐานสิบหก ตวั เลขแตล่ ะหลักมีค่าจาก 0 ถึง 9 และตวั อกั ษร A คือ 10, B คือ11 ไปจนถึง F ซงึ่ เท่ากบั 15ตวั อยา่ ง 0x101 == 257 decimal ( (1 * 16^2) + (0 * 16^1) + 1)3.10 ค่าคงที่ (constants) ค่าคงทเี่ ปน็ กลุ่มตวั อกั ษรหรอื ข้อความทีไ่ ด้กาหนดค่าไว้ล่วงหน้าแล้ว ตัวคอมไพเลอร์ของ Arduinoจะรู้จักกับค่าคงที่เหลา่ น้แี ล้ว ไม่จาเปน็ ตอ้ งประกาศหรอื กาหนดค่าคงที่ 3.10.1 HIGH,LOW : ใชก้ าหนดค่าทางตรรกะ ในการอา่ นหรอื เขยี นค่าให้กบั ขาทเ่ี ป็นดจิ ติ อล คา่ ท่เี ปน็ ไดม้ ี 2 ค่าคือ HIGH หรอื LOW เทา่ นน้ั HIGH เป็นการกาหนดคา่ ให้ขาดิจิตอลน้ันมีแรงดันเท่ากบั +5V ในการอา่ นค่า ถ้าอา่ นได้ +3V หรือมากกว่าไมโครคอนโทรลเลอรจ์ ะอ่านคา่ ได้เป็น HIGH คา่ คงทขี่ อง HIGH กค็ อื “1” หรือเทยี บเป็นตรรกะคอื จริง (TRUE) LOW เป็นการกาหนดค่าใหข้ าดจิ ิตอลนัน้ มแี รงดันเท่ากับ 0V ในการอ่านค่า ถ้าอ่านได้ +2V หรือน้อยกว่าไมโครคอนโทรลเลอรจ์ ะอา่ นคา่ ไดเ้ ปน็ LOW คา่ คงที่ของ LOW ก็คอื “0” หรือเทยี บเปน็ ตรรกะคือเท็จ (FLSE)หนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรียงโดยครทู ันพงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้อื งต้น 30 3.10.2 INPUT, OUTPUT : กาหนดทศิ ทางของขาพอร์ตดิจติ อล ขาของพอร์ตดิจิตอลทาหน้าที่ได้ 2 อย่างคือ เป็นอินพุต (INPUT) หรือเอาต์พุต (OUTRUT) ซ่ึงค่าคงท่ีนี้ก็ระบไุ ว้ชดั เจน 3.11 ตัวกระทาอ่ืนๆ ที่เกี่ยวข้องกับตัวแปร 3.11.1 cast : การเปลี่ยนประเภทตวั แปรชว่ั คราว Cast เป็นตวั กระทาทใี่ ช้สั่งใหเ้ ปลี่ยนประเภทของตัวแปรไปเป็นประเภทอื่น และบงั คับให้คานวณค่าตัวแปรเปน็ ประเภทใหม่ รูปแบบคาสัง่ (type) variable เมือ่ Type เป็นประเภทของตัวแปรใดๆ (เชน่ int, float, long) Variable เปน็ ตัวแปรหรอื คา่ คงทีใ่ ดๆ ตัวอยา่ งท่ี 3.37 int i; float f; f = 3. 6; i = (int) f; // now i is 3 ในการเปล่ียนประเภทตัวแปรจาก float เป็น int ค่าท่ไี ดจ้ ะถกู ตดั เศษออก ดังน้ัน (int)3.2 และ (int)3.7 มีค่าเทา่ กันคอื 3 3.11.2 sizeof : แจ้งขนาดของตัวแปร ใชแ้ จง้ บอกจานวนไบตข์ องตัวแปรที่ต้องการทราบคา่ ซึ่งเป็นทงั้ ตัวแปรปกติและตัวแปรอะเรย์ รูปแบบคาสง่ั เขียนได้ทง้ั สองแบบดังนี้ sizeof (variable) sizeof (variable) เมอื่ Variable คอื ตวั แปรปกติหรอื ตวั แปรอะเรย์ (int, float, long) ท่ตี อ้ งการทราบขนาด ตัวอยา่ ง 3.38 ตัวกระทา sizeof มีประโยชน์อย่างมากในการจัดการกับตัวแปรอะเรย์ (รวมถึงตัวแปรสตริง) ตัวอย่างต่อไปนจ้ี ะพิมพข์ อ้ ความออกทางพอร์ตอนกุ รมครั้งละหนง่ึ ตวั อกั ษร ใหท้ ดลองเปล่ียนขอ้ ความหนว่ ยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทันพงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบ้อื งตน้ 31 char myStr [ ] =”this is a test”; int i;void setup ( ) { Serial . begin(9600); {void loop ( ) { for (i = 0; I < sizeof (myStr) – 1; i++ { Serial .print (i, DEC); Serial .print (“ = “ ); Serial .println (myStr[i], BYTE); } }หนว่ ยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรยี งโดยครทู ันพงษ์ ภ่รู กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บอ้ื งต้น 32 3.12 คาสงวนของ Arduino คาสงวนคือ ค่าคงที่ ตัวแปร และฟังก์ช่ันท่ีกาหนดไว้เป็นส่วนหนึ่งของภาษา C ของ Arduino ห้ามนาคาเหลา่ น้ไี ปตงั้ ช่อื ตัวแปรแสดงได้ดังนี้ # ## ##Constants other otherHIGH Port Constants Datatypes += absLOWINPUT DDRB boolean +[ acosOUTPUT ] analogReadSERIAL PINB byte =&& analogWriteDISPLAY = attachInterruptsPI PORTB char || asinHALF_ PI = atanTWO_PI DDRC class ,/ atan2LSBFIRST / availableMSBFIRST PINC default ?: beginCHANGE << bitFALLING PORTC do << bitReadRISING = bitWritefalse DDRD double log bitSettrue && bitClearnull PIND int !| boolean | byte PORTD long ^^ case = ceil private ++ char != char protected - class % abs public / acos return shot signed static switch throw Try Unsigned Void whileหนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรียงโดยครูทนั พงษ์ ภู่รักษ์
หนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบ้ืองต้น 33 * constrain { cos } default / / delay ** delayMicroseconds . detachInterrupts - digitalWrite = digitalRead == else << exp = false () find >> findUntil ; float floor for HALF_PI if int log loop map max micros millis min new noInterrupts noTone null parseInt parseFloat เรยี บเรยี งโดยครูทนั พงษ์ ภรู่ ักษ์
หนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบื้องตน้ 34 pinMode print println pulseIn radians this tone true write # USB Keyboard Mouse read press release releaseAll readBytes readBytesUntil return round serial serial1 serial2 serial3 setTimeout Setup shiftIn shiftOut sin sq sqrt tan เรยี บเรยี งโดยครทู ันพงษ์ ภูร่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบอ้ื งตน้ 35สรปุ เนอ้ื หาสาระสาคัญ โปรแกรมทางานวนในฟงั กช์ ัน่ loop() ตลอดเวลา หลงั จากทางานในฟังก์ช่ัน setup() จึงสรุปได้ว่า ฟังก์ช่ันsetup() คือส่วนตน้ ของโปรแกรมทีใ่ ช้ในการประกาศ หรือตั้งค่าการทางานในตอนเริ่มต้นทางาน ในขณะท่ีฟังก์ช่ันloop() เป็นเสมือนส่วนของโปรแกรมหลักที่ต้องวนทางานอย่างต่อเนื่องตลอดเวลาอย่างไรก็ตามในบางโปรแกรมอาจมีเฉพาะสว่ นของฟงั กช์ ่ัน setup() และไม่มีฟงั ก์ช่นั loop() กไ็ ด้แสดงว่าโปรแกรมน้ันๆ ต้องการตั้งค่าการทางานหรือกาหนดใหม้ กี ารทางานเพยี งครงั้ หรอื รอบเดียว แล้วจบการทางานทนั ที เทคนคิ สาหรับการเขียนโปรแกรม เลือกขนาดของตัวแปรใหใ้ หญ่พอสาหรับเก็บคา่ ผลลพั ธ์ทีม่ ากท่สี ดุ ของการคานวณ ต้องทราบว่าท่ีค่าใด ตัวแปรที่เก็บจะมีการวนซา้ คา่ กลับ และวนกลับอย่างไร สาหรบั การคาณวณทตี่ ้องการเศษส่วนใหใ้ ช้ตัวแปรประเภท float แต่ให้ระวังผลลบ เช่นตัวแปรมีขนาดใหญ่ คานวณได้ช้า ใช้ตัวกระทา cast เช่น (int)myfloat ในการเปลี่ยนประเภทของตัวแปรช่วั คราวขณะทโ่ี ปรแกรมทางาน. เรียบเรียงโดยครทู นั พงษ์ ภรู่ กั ษ์หนว่ ยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบ้ืองต้น 36 แบบฝึกหัดหน่วยที่ 3เรือ่ ง โครงสร้างโปรแกรมของ Arduino ใช้เวลา 20 นาที*******************************************************************************************************คาช้ีแจง แบบฝกึ หัดมที ัง้ หมด 2 ตอน ประกอบดว้ ยตอนท่ี 1 และตอนท่ี 2 (20 คะแนน)2. แบบฝกึ หดั ตอนที่ 1 เปน็ คาถามแบบถูก-ผดิ มีทงั้ หมด 20 ข้อ (10 คะแนน)3. แบบฝึกหดั ตอนท่ี 2 เป็นคาถามแบบปรนยั มที ง้ั หมด 10 ข้อ (10 คะแนน) แบบฝกึ หัดตอนท่ี 1คาช้ีแจง ให้ผูเ้ รียนกาเครอื่ งหมายถกู ในข้อท่คี ิดว่าถูก และกาเคร่อื งหมายผิด ในข้อทค่ี ดิ ว่าผิด 1. #define เปน็ คาสั่งที่ใชง้ านมาก ในการกาหนดค่าคงทีใ่ หก้ บั โปรแกรม 2. ทา้ ยคาสงั่ # define ตอ้ งมเี คร่ืองหมายเซมิโคลอน 3. #include ใช้สัง่ ให้รวมไฟล์อนื่ ๆ เข้ากับไฟล์โปรแกรมหลัก แล้วจงึ ทาการคอมไพลโ์ ปรแกรม 4. char : ตัวแปรประเภทตัวอักขระมขี นาด 1 ไบต์ (8 บติ ) มีไว้เพื่อเกบ็ ค่าตัวอกั ษร 5. byte : ตวั แปรประเภทตัวเลบ 8 บติ หรอื 1 ไบต์ ใช้เกบ็ ค่าตัวเลขขนาด 8 บิต มีค่าไดจ้ าก 0 - 255 6. int : ตัวแปรประเภทตวั เลขจานวนเต็ม มขี นาด 1 ไบต์ เก็บคา่ ได้ จาก -32,768 ถึ ง 32,767 7. unsigned int : ตวั แปรประเภทเลขจานวนเตม็ ไมค่ ดิ เครื่องหมาย เก็บคา่ 0 ถงึ 65,535 8. long : ตัวแปรประเภทเลขจานวนเต็ม (4 ไบต์ ) เก็บค่าได้จาก -2,147,483,648 ถึง 2,147,483,647 9. unsigned long : ตัวแปรประเภทเลขจานวนเต็ม 16 บติ แบบไม่คดิ เครื่องหมาย เกบ็ ค่าได้ จาก 0 ถึง 4,294,967,295 10. string : ตัวแปรประเภทขอ้ ความ เป็นตวั แปรเกบ็ ขอ้ ความ ซึ่งในภาษาซี จะนิยามเปน็ อะเรย์ของตวั แปรประเภท charหน่วยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรยี งโดยครทู ันพงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บอื้ งตน้ 37 แบบฝกึ หดั ตอนท่ี 2คาชแ้ี จง ให้ผ้เู รียนเลือกคาตอบที่ถกู ทสี่ ุดแลว้ กาเครื่องหมายกากบาท () ใหค้ รบทกุ ข้อ1. การเขยี นโปรแกรมสาหรบั Arduino จะอา้ งอิงตามภาษา ก. C/C++ ข. English / Thai ค. Assembly Language ง. Java Language2. ฟังกช์ นั่ setup() เม่อื โปรแกรมเริม่ ตน้ ทางานจะทาคาสั่งนก้ี คี่ รง้ั ก. ทาคาส่งั ของฟังก์ชนั่ น้ี 1 ครง้ั ข. ทาคาสง่ั ของฟงั กช์ ่ันนี้ 2 ครัง้ ค. ทาคาสงั่ ของฟงั ก์ชนั่ นี้ 3 ครัง้ ง. ทาคาสงั่ ของฟงั ก์ช่นั นี้ 4 ครง้ั3. คาส่ัง if ใชเ้ พือ่ กาหนดเง่ือนไขการทางานของโปรแกรมอย่างไร ก. ถา้ เงอ่ื นไขเป็นเทจ็ ทาตามคาสั่งทเ่ี ขียนในวงเล็บปกี กา ถา้ เงอ่ื นไขเปน็ จริงข้ามการทางาน ข. ถา้ เงื่อนไขเปน็ จริงทาตามคาส่งั ทีเ่ ขียนในวงเลบ็ ปีกกา ถา้ เงอ่ื นไขเปน็ เท็จขา้ มการทางาน ค. ถ้าเงื่อนไขเป็นจริงทาตามคาส่งั ทเ่ี ขียนในวงเลบ็ ปีกกา ถา้ เงื่อนไขเป็นจรงิ ขา้ มการทางาน ง. ถา้ เง่อื นไขเปน็ เท็จทาตามคาสัง่ ท่ีเขยี นในวงเล็บปกี กา ถ้าเงอื่ นไขเป็นเทจ็ ข้ามการทางาน4. คาส่งั for() แบ่งได้ 3 ส่วนอะไรบา้ ง ก. initialition; condition; increment ข. initialization; contion; increment ค. initialization; condition; crement ง. initialization; condition; increment5. ผลทไี่ ด้จากการหารเอาเศษของ x = 5 % 5 ก. 1 ข. 0 ค. 0.1 ง. 0.5หน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทนั พงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบื้องต้น 386. ตวั กระทาเปรยี บเทยี บใช้สาหรบั ประกอบกบั คาสั่งใด ก. if() และ while() ข. switch() และ case() ค. for() และ while() ง. for() และ if()7. ตรรกะที่ใช้ในการเปรียบเทียบของคาส่งั if() คือ ก. && และ ! ข. || และ ! ค. &&, || ง. &&, || และ !8. ตวั กระทาระดบั บติ NOT ใชส้ ัญญลกั ษณใ์ ด ก. ~ ข. α ค. β ง. €9. หมายเหตบุ รรทดั เดียวและหลายบรรทัดคอื ขอ้ ใด ก. / / และ / * . . . */ ข. / / และ * / . . . /* ค. / / และ */ . . . */ ง. / / และ / * . . . /*10. ตวั แปร unsigned long เป็นตวั แปรประเภทใด ก. ตวั แปรจานวนเตม็ 8 บิต แบบคิดเครือ่ งหมาย ข. ตัวแปรจานวนเตม็ 16 บิต แบบคดิ เครอื่ งหมาย ค. ตัวแปรจานวนเตม็ 32 บิต แบบไมค่ ดิ เครอื่ งหมาย ง. ตวั แปรจานวนเต็ม 64 บติ แบบไม่คิดเคร่อื งหมายหนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรยี งโดยครูทนั พงษ์ ภรู่ ักษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบือ้ งตน้ 39 ปฏิบัตกิ ารทดลองหนว่ ยที่ 3 เรื่อง โครงสรา้ งโปรแกรมของ Arduino*******************************************************************************************************คาช้ีแจง ให้ผู้เรียนทุกคนทาการทดลองตามปฎิบัติการทดลองหน่วยท่ี 3 เรื่อง โครงสร้างโปรแกรมของ Arduinoโดยใช้เวลา 180 นาที ( 20 คะแนน)จุดประสงคเ์ ชิงพฤติกรรม 1. สามารถเขียนโครงสรา้ งโปรแกรมของ Arduino ได้ถกู ตอ้ ง 2. สามารถแกป้ ญั หาในการทางานของบอร์ด Arduino Uno R3 ได้ 3. สามารถต่อใช้งานและอพั โหลดโปรแกรมของบอร์ด Arduino Uno R3 ได้อปุ กรณก์ ารทดลอง 1 ชดุ 1. เครื่องคอมพวิ เตอร์และโปรแกรม Arduino IDE 1.6.9 1 เส้น 2. USB Cable Arduino Uno R3 1 บอรด์ 3. Arduino Uno R3 Board 10 เสน้ 6. Hook-up Wires 1 แผง 7. Breadboard 6 ตัว 8. LED 2 ตัว 9. Momentary Button or Pushbutton Switch 2 ตัว 10. 10K Ohm Resistor 6 ตัว 11. 220 Ohm Resistor 1 ตัว 12. Potentiometer or Variable Resistor 1 ตัว 13. Photoresistor or Another Analog Sensorข้อควรระวงั 1. ควรระวังไม่วางบอร์ด Arduino Uno R3 หรือชลี ตา่ งๆ บนโต๊ะโลหะหรือท่วี างท่ีเปน็ โลหะเพราะอาจเกิดการลัดวงจรของภาคจา่ ยไฟได้ 2. ไม่ควรต่อสายต่อวงจรในบอร์ด Arduino Uno R3 ท้ิงไว้ ควรถอดสายต่อวงจรออกให้หมด เพราะผลการทดลองอาจเกดิ การผดิ พลาดไม่เป็นไปตามทฤษฎไี ด้ 3. ไม่ควรถอดสายสายโหลด USB เข้าออกตลอดเวลา เพราะอาจทาให้ภาคจ่ายไฟของบอร์ด ArduinoUno R3 เสยี หายได้หน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครทู นั พงษ์ ภ่รู ักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บื้องตน้ 40การทดลองท่ี 3.1 ฟงั ก์ชัน่ setup() ฟังกช์ ัน่ น้ีจะเขียนที่สว่ นตน้ ของโปรแกรม ทางานเมือ่ โปรแกรมเริ่มตน้ เพียงครัง้ เดยี วใช้เพอื่ กาหนดคา่ ของตัวแปรโหมดการทางานของขาตา่ งๆ เร่มิ ต้นเรยี กใช้ ไลบรารี ฯลฯHardware Required 1. Arduino Uno BoardCode void setup() { Serial.begin(9600); } void loop() { int sensorValue = analogRead(A0); float voltage = sensorValue * (5.0 / 1023.0); Serial.println(voltage); } // จากนั้นใหน้ ักเรียนปรบั เปลยี่ นคา่ Serial.begin แลว้ สงั เกตุผลทไ่ี ด้ผลการทดลอง............................................................................................................................. ...................................................................................................................................................................................................................................................................................................................................................... ........................................................................................................................................................................... ........................................................................................................................................................................... ..............................................หน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครทู นั พงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบื้องต้น 41การทดลองที่ 3.2 ฟงั กช์ ่ัน loop() หลังจากทเี่ ขยี นฟังก์ช่ัน setup() ท่ีกาหนดค่าเร่ิมต้นของโปรแกรมแล้ว ส่วนถัดมาคือฟังก์ช่ัน loop() ซึ่งมีการทางานตรงตามชื่อ คือจะทางานตามฟังกช์น่ัน วนตอ่ เนอื่ งตลอดเวลา ภายในฟงั กชน์ ั่นจะมีโปรแกรมของผูใ้ ช้เพอ่ืรับค่าจากพอรต์ ประมวลผลแลว้ ส่งั เอาต์พุตออกขาตา่ งๆ เพื่อควบคมุ การทางานของบอร์ดHardware Required 1. Arduino Uno BoardCode const int buttonPin = 13 void setup(){ Serial.begin(9600); pinMode(buttonPin, INPUT);} void loop(){ if (digitalRead(buttonPin) == HIGH) Serial.write('H'); else Serial.write('L'); delay(1000);} // จากนั้นใหน้ ักเรียนเปลย่ี นคา่ Serial.write('H');เปน็ Serial.write('L');แล้วสังเกตุผลที่ได้ผลการทดลอง............................................................................................................................. ...................................................................................................................................................................................................................................................................................................................................................... ........................................................................................................................................................................... .............................................หน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรียบเรยี งโดยครูทันพงษ์ ภ่รู กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บือ้ งตน้ 42การทดลองที่ 3.3 คาส่ัง if ใช้ทดสอบเพ่ือกาหนดเง่อื นไขการทางานของโปรแกรม โดยสามารถกาหนดได้ ว่าถ้าเง่ือนไขเป็นจริงให้ทาอะไร ถา้ เป็นเท็จให้ทาอะไรHardware Required 1. Arduino uno Board 2. Momentary button or Switch 3. 10K ohm resistor 4. hook-up wires 5. breadboardCircuitSchematicหน่วยท่ี 3 โครงสรา้ งโปรแกรมของ Arduino เรียบเรียงโดยครูทนั พงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้ืองตน้ 43Code const int buttonPin = 2; const int ledPin = 13; int buttonState = 0; void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); } void loop() { buttonState = digitalRead (buttonPin); if (buttonState == HIGH) { digitalWrite(ledPin, HIGH); } //จากนัน้ ใหเ้ ปล่ียนคา่ if (buttonState == HIGH)เป็น if (buttonState == LOW)แล้วสงั เกตุผล ผลการทดลอง ............................................................................................................................. ........................................ ..................................................................................................................................................................... ............................................................................................................................. ........................................ ............................................................................................................................................. ........................ .......................................................................................................... ........................................................... ............................................................................................................................. ........................................ ............................................................................................................................................................ ......... .......................................................................................................................... ........................................... ............................................................................................................................. ........................................ ..................................................................................................................................................................... ............................................................................................................................. ........................................ .....................................................................................................................................................................หน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครูทนั พงษ์ ภ่รู กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้ืองตน้ 44การทดลองท่ี 3.4 คาสง่ั if…else ใช้ทดสอบเพื่อกาหนดเง่ือนไขการทางานของโปรแกรมได้มากกว่าคาส่ัง if ธรรมดา โดยสามารถกาหนดได้วา่ ถา้ เงื่อนไขเปน็ จริงใหท้ าอะไร ถา้ เปน็ เท็จใหท้ าอะไรHardware Required 1. Arduino or Genuino Board 2. Potentiometer or variable resistorCircuitSchematicหนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรียงโดยครทู นั พงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบ้อื งตน้ 45Codeconst int analogPin = A0; // pin that the sensor is attached toconst int ledPin = 13; // pin that the LED is attached toconst int threshold = 400; // an arbitrary threshold level that's in the range of theanalog inputvoid setup() { // initialize the LED pin as an output: pinMode(ledPin, OUTPUT); // initialize serial communications: Serial.begin(9600);}void loop() { // read the value of the potentiometer: int analogValue = analogRead(analogPin); // if the analog value is high enough, turn on the LED: if (analogValue > threshold) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); } // print the analog value: Serial.println(analogValue); delay(1); // delay in between reads for stability}ผลการทดลอง............................................................................................................................. ..................................................................................................................................................................... .................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... ........................หนว่ ยที่ 3 โครงสรา้ งโปรแกรมของ Arduino เรยี บเรียงโดยครทู ันพงษ์ ภูร่ ักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบื้องตน้ 46 การทดลองท่ี 3.5 คาสง่ั for() คาส่ังน้ีใช้เพื่อส่ังให้คาสั่งที่อยู่ภายในวงเล็บปีกกาหลัง for มีการทางานซ้ากันตามจานวนรอบท่ีต้องการคาส่งั น้มี ีประโยชน์มากสาหรับการทางานใดๆ ที่ต้องทาซ้ากันและทราบจาานวนรอบของการทางานท่ีแน่นอนใช้คู่กับตัวแปรอะเรย์ในการเก็บสะสมค่า ท่ีอ่านค่าได้จากขาอินพุตแอนะล็อกหลายๆ ขาที่มีหมายเลขขาต่อเนื่องกันรูปแบบของคาส่ั ง for() แบ่งได้ 3 ส่วนดังน้ี for (initialization; condition; increment) { //statement(s); } Hardware Required 1. Arduino or Genuino Board 2. 220 ohm resistors 6 PCS 3. LEDs 6 PCS 4. hook-up wires 5. breadboardหน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรียงโดยครทู ันพงษ์ ภู่รกั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอร์เบอื้ งตน้ 47CircuitSchematicหนว่ ยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครทู นั พงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอร์เบ้ืองตน้ 48Codeint timer = 100; // The higher the number, the slower the timing.void setup() { // use a for loop to initialize each pin as an output: for (int thisPin = 2; thisPin < 8; thisPin++) { pinMode(thisPin, OUTPUT); }}void loop() { // loop from the lowest pin to the highest: for (int thisPin = 2; thisPin < 8; thisPin++) { // turn the pin on: digitalWrite(thisPin, HIGH); delay(timer); // turn the pin off: digitalWrite(thisPin, LOW); } // loop from the highest pin to the lowest: for (int thisPin = 7; thisPin >= 2; thisPin--) { // turn the pin on: digitalWrite(thisPin, HIGH); delay(timer); // turn the pin off: digitalWrite(thisPin, LOW); }}}ผลการทดลอง............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................หนว่ ยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรยี งโดยครูทันพงษ์ ภู่รักษ์
เอกสารประกอบการสอนวิชาไมโครคอนโทรลเลอรเ์ บ้ืองตน้ 49การทดลองที่ 3.6 คาส่งั switch-case ใช้ทดสอบเงื่อนไขเพื่อกาหนดการทางานของโปรแกรม ถ้าตัวแปรที่ทดสอบตรงกับเง่ือนไขใดก็ให้ทางานตามท่กี าหนดไวพ้ ารามเิ ตอร์ var ตวั แปรท่ีต้ องการทดสอบวา่ ตรงกับเงื่อนไขใด default ถ้าไม่ตรงกับเงอ่ื นไขใดๆ เลยให้ทาคาสง่ั ต่อท้ายนี้ break เป็นส่วนสาคัญมากใช้เขียนต่อท้าย case ต่างๆ เม่ือพบเง่ือนไขนั้นแล้วทาตามคาส่ังต่างๆแล้วให้หยดุ การทางานของคาส่ั ง switch-case ถา้ ลืมเขยี น break เม่ือพบเง่ือนไขทาตามเงื่อนไขแล้วโปรแกรมจะทางานตามเง่ือนไขต่อไปเรื่อยๆ จนกว่าจะพบคาส่ัง breakHardware Required 1. Arduino or Genuino Board 2. photoresistor, or another analog sensor 3. 10k ohm resistors 4. hook-up wires 5. breadboarCircuitหน่วยที่ 3 โครงสร้างโปรแกรมของ Arduino เรยี บเรียงโดยครูทนั พงษ์ ภรู่ กั ษ์
เอกสารประกอบการสอนวชิ าไมโครคอนโทรลเลอรเ์ บื้องตน้ 50SchematicCodeconst int sensorMin = 0; // sensor minimum, discovered through experimentconst int sensorMax = 600; // sensor maximum, discovered through experimentvoid setup() { // initialize serial communication: Serial.begin(9600);}void loop() { // read the sensor: int sensorReading = analogRead(A0); // map the sensor range to a range of four options: int range = map(sensorReading, sensorMin, sensorMax, 0, 3);// do something different depending on the// range value:switch (range) { case 0: // your hand is on the sensorหน่วยท่ี 3 โครงสร้างโปรแกรมของ Arduino เรียบเรียงโดยครูทันพงษ์ ภู่รักษ์
Search
