C-Manual-IPST-MicroBOX [SE]

ความรู้เกี่ยวกับภาษา C/C++ Arduino IDEและฟังก์ชนั่ ของ สำ�หรบั ชุดกลอ่ งสมองกล • โครงสร้างภาษา C/C++ ที่ใช้ในซอฟต์แวร์ Arduino IDE • ขอ้ ควรรเู้ ก่ียวกบั ตัวแปรในภาษา C/C++ ของ Arduino • ฟงั กช์ นั่ พืน้ ฐานของ Arduino และ ตัวอย่างค�ำสงั่ www.ipst-microbox.com

   Arduino IDE1     Arduino IDE       Arduino Programming Reference with IPST-MicroBOX Secondary Education (SE)

2   Arduino IDE ความรเู กีย่ วกบั ภาษา C/C++ และฟง กช น่ั ของ Arduino IDE สาํ หรบั ชดุ กลอ งสมองกล IPST-MicroBOX (SE) ISBN 974 - 92023 - 0 -9 สงวนลขิ สิทธิ์ตาม พ.ร.บ. ลิขสิทธ์ิ พ.ศ. 2521 หา มการลอกเลยี นไมว าสวนหนึ่งสวนใดของหนังสือเลมนี้ นอกจากจะไดร ับอนุญาต ใครควรใชห นงั สอื เลม นี้ 1. นกั เรยี น นสิ ติ นกั ศกึ ษา และบคุ คลทว่ั ไปทมี่ คี วามสนใจในการนาํ ไมโครคอนโทรลเลอรไ ปประยกุ ตใ ชใ นการทดลอง ทางวทิ ยาศาสตร หรอื สนใจในการเรยี นรแู ละทดลองวิยาศาสตรใ นแนวทางใหมท ่ีใชก จิ กรรมเปนส่ือ โดยมไี มโคร คอนโทรลเลอรเ ปน สว นประกอบ 2. สถาบนั การศกึ ษา โรงเรยี น วทิ ยาลยั มหาวทิ ยาลยั ทมี่ กี ารเปด การเรยี นการสอนวชิ าอเิ ลก็ ทรอนกิ สห รอื ภาควชิ า วศิ วกรรมอเิ ลก็ ทรอนกิ สแ ละคอมพวิ เตอร 3. คณาจารยท มี่ คี วามตอ งการศกึ ษา และเตรยี มการเรยี นการสอนวชิ าไมโครคอนโทรลเลอร รวมถงึ วทิ ยาศาสตร ประยุกตท่ีตองการบูรณาการความรูทางอิเล็กทรอนิกส-ไมโครคอนโทรลเลอร-การเขียนโปรแกรมคอมพิวเตอร- การทดลองทางวทิ ยาศาสตร ในระดบั มธั ยมศกึ ษา อาชวี ศกึ ษา และปรญิ ญาตรี ดาํ เนนิ การจดั พมิ พแ ละจาํ หนา ยโดย บรษิ ทั อนิ โนเวตฟี เอก็ เพอรเิ มนต จาํ กดั 108 ซ.สขุ มุ วทิ 101/2 ถ.สขุ มุ วทิ แขวงบางนา เขตบางนา กรุงเทพฯ 10260 โทรศพั ท 0-2747-7001-4 โทรสาร 0-2747-7005 รายละเอียดท่ปี รากฏในหนังสือความรเู กยี่ วกับภาษา C/C++ และฟงกช น่ั ของ Arduino IDE สําหรับชดุ กลอ ง สมองกล IPST-MicroBOX (SE) ผา นการตรวจทานอยา งละเอียดและถว นถ่ี เพอ่ื ใหม คี วามสมบูรณแ ละถกู ตอ ง มากทส่ี ดุ ภายใตเ งอื่ นไขและเวลาทพ่ี งึ มกี อ นการจดั พมิ พเ ผยแพร ความเสยี หายอนั อาจเกดิ จาก การนาํ ขอ มลู ใน หนังสือเลมน้ีไปใช ทางบรษิ ัท อินโนเวตฟี เอ็กเพอริเมนต จาํ กัด มไิ ดม ภี าระในการรับผิดชอบแตป ระการใด ความผดิ พลาดคลาดเคลอ่ื นทอี่ าจมแี ละไดร บั การจดั พมิ พเ ผยแพรอ อกไปนน้ั ทางบรษิ ทั ฯ จะพยายามชแี้ จงและ แกไ ขในการจดั พมิ พค รงั้ ตอ ไป

    Arduino IDE3  การนาํ เสนอขอ มลู เกยี่ วกบั ขอ มลู ทางเทคนคิ และเทคโนโลยใี นหนงั สอื เลม น้ีเกดิ จากความตอ ง การทจ่ี ะอธบิ ายกระบวนการและหลกั การทาํ งาน ของอปุ กรณใ นภาพรวมดว ยถอ ยคาํ ทง่ี า ยเพอื่ สรา ง ความเขา ใจแกผ อู า น ดงั นนั้ การแปลคาํ ศพั ทท างเทคนคิ หลายๆ คาํ อาจไมต รงตามขอ บญั ญตั ขิ องราช บัณฑติ ยสถาน และมหี ลายๆ คาํ ทีย่ งั ไมม กี ารบญั ญัตอิ ยา งเปนทางการ คณะผเู ขียนจึงขออนญุ าต บญั ญตั ศิ พั ทข นึ้ มาใชใ นการอธบิ าย โดยมขี อ จาํ กดั เพอ่ื อา งองิ ในหนงั สอื เลม นเี้ ทา นน้ั ทงั้ นส้ี าเหตหุ ลกั ของขอ ชแ้ี จงนมี้ าจาก การรวบรวมขอ มลู ของอปุ กรณใ นระบบสมองกลฝง ตวั และเทคโนโลยหี นุ ยนตส าํ หรบั การศกึ ษาเพอื่ นาํ มาเรยี บเรยี งเปน ภาษาไทยนนั้ ทาํ ไดไ มง า ยนกั ทางคณะ ผเู ขยี นตอ งทาํ การรวบรวมและทดลองเพอื่ ใหแ นใ จวา ความเขา ใจในกระบวนการทาํ งานตา งๆ นน้ั มคี วาม คลาดเคลอ่ื นนอ ยทสี่ ดุ เมอ่ื ตอ งทาํ การเรยี บเรยี งออกมาเปน ภาษาไทย ศพั ทท างเทคนคิ หลายคาํ มคี วามหมายทท่ี บั ซอ น กนั มากการบญั ญตั ศิ พั ทจ งึ เกดิ จากการปฏบิ ตั จิ รงิ รว มกบั ความหมายทางภาษาศาสตรดงั นน้ั หากมคี วาม คลาดเคลอ่ื นหรอื ผดิ พลาดเกดิ ขนึ้ ทางคณะผเู ขยี นขอนอ มรบั และหากไดร บั คาํ อธบิ ายหรอื ชแ้ี นะจากทา น ผรู จู ะไดท าํ การชแ้ี จงและปรบั ปรงุ ขอ ผดิ พลาดทอี่ าจมเี หลา นนั้ โดยเรว็ ทสี่ ดุ ทงั้ นเี้ พือ่ ใหการพัฒนาสอ่ื ทางวชิ าการ โดยเฉพาะอยา งยง่ิ กับความรูของเทคโนโลยีสมยั ใหม สามารถดาํ เนนิ ไปไดอ ยา งตอ เนอ่ื ง ภายใตก ารมสี ว นรว มของผรู ใู นทกุ ภาคสว น บริษัท อนิ โนเวตฟี เอ็กเพอริเมนต จาํ กดั หนังสือเลมน้ีเปนสวนหน่ึงของชุดกลองสมองกล IPST-MicroBOX Seconday Edition (SE) โดยใชประกอบใน การเรยี นรแู ละฝก ฝนเกย่ี วกบั การเขยี นและพฒั นาโปรแกรมภาษา C/C++ เพอ่ื นาํ มาพฒั นาโปรแกรมสาํ หรบั กาํ หนด และควบคมุ การทํางานของแผงวงจรตา งๆ ในชุดกลองสมองกล IPST-MicroBOX (SE)

4      Arduino IDE  คาํ ชแ้ี จงจากคณะผเู ขยี น/เรยี บเรยี ง..................................................................................................3 บทที่ 1 โครงสรา งภาษา C/C++ทใี่ ชใ นซอฟตแ วรArduino IDE.......................................................5 บทท่ี 2 ขอ ควรรเู กยี่ วกบั ตวั แปรในภาษาC/C++ของ Arduino...................................................39 บทท่ี 3 ฟง กช น่ั พน้ื ฐานของ Arduino และตวั อยา งคาํ สงั่ .......................................................... 55

  Arduino IDE5    Arduino ในการเขยี นโปรแกรมสาํ หรบั แผงวงจรIPST-SEจะตอ งเขยี นโปรแกรมโดยใชภ าษาC/C++ของ Arduino (Arduino programming language) เวอรช นั 1.0 ขน้ึ ไป ภาษาของ Arduino แบง ไดเ ปน 2 สว น หลกั คอื 1. โครงสรา งภาษา (structure) ตัวแปรและคาคงที่ 2. ฟง กช่นั (function) ภาษาของ Arduino จะอางอิงตามภาษา C/C++ จึงอาจกลาวไดว า การเขียนโปรแกรมสาํ หรบั Arduino (รวมถงึ แผงวงจร IPST-SE) ก็คือการเขียนโปรแกรมภาษา C โดยเรียกใชงานฟงกช่ันและ ไลบรารที ที่ าง Arduino ไดเ ตรยี มไวใ หแ ลว ซงึ่ สะดวก ทาํ ใหผ ทู ไ่ี มม คี วามรดู า นไมโครคอนโทรลเลอร อยางลึกซ้ึงสามารถเขียนโปรแกรมสั่งงานได 1.1 โครงสรางโปรแกรมของ Arduino โปรแกรมของ Arduino แบง ไดเ ปนสองสว นคอื void setup() และ void loop() โดยฟง กช น่ั setup() เมอ่ื โปรแกรมทาํ งานจะทาํ คาํ สง่ั ของฟง กช น่ั นเี้ พยี งครงั้ เดยี ว ใชใ นการ กําหนดคาเรมิ่ ตน ของการทาํ งาน สว นฟง กช น่ั loop() เปนสว นทํางาน โปรแกรมจะกระทําคําสงั่ ใน ฟงกชั่นน้ีตอเนื่องกันตลอดเวลา โดยโคด โปรแกรมท่ีทาํ งานใน loop()มักเปนคําสั่งอา นคาอนิ พตุ ประมวลผล สงั่ งานเอาตพตุ ฯลฯ สว นกาํ หนดคา เรม่ิ ตน เชน ตวั แปร จะตอ งเขยี นไวท ส่ี ว นหวั ของโปรแกรม กอ นถงึ ตวั ฟง กช นั่ นอกจากนั้นยังตองคํานึงถึงตัวพิมพเล็ก-ใหญของตัวแปรและช่ือฟงกช่ันใหถูกตองดวย

6     Arduino IDE 1.1.1 สว นของฟง กช นั่ setup() ฟง กช่นั นีจ้ ะเขียนที่สว นตนของโปรแกรม ทํางานเมื่อโปรแกรมเรม่ิ ตนเพยี งคร้ังเดียว ใชเพอ่ื กําหนดคาของตัวแปร, โหมดการทาํ งานของขาตางๆ หรอื เริ่มตนเรียกใชไ ลบรารี ฯลฯฯ ตัวอยางท่ี 1-1 int buttonPin = 3; void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); } void loop() { if (digitalRead(buttonPin) == HIGH) Serial.write('H'); else Serial.write('L'); delay(1000); } ในขณะทโี่ ปรแกรมภาษา C มาตรฐานทเี่ ขยี นบน AVR GCC (เปน โปรแกรมภาษา C ทใ่ี ชค อม ไพเลอรแ บบ GCC สาํ หรับไมโครคอนโทรลเลอร AVR) จะเขยี นไดด งั นี้ int main(void) ตรงกบั void setup() { ตรงกบั void loop() init(); setup(); for (;;) loop(); return ; }

  Arduino IDE7 1.1.2 สวนของฟงกช น่ั loop() หลงั จากทเ่ี ขยี นฟง กช นั่ setup()ทก่ี าํ หนดคา เรมิ่ ตน ของโปรแกรมแลว สว นถดั มาคอื ฟง กช นั่ loop() ซ่งึ มีการทํางานตรงตามช่อื คอื จะทาํ งานตามฟง กช ่ันนี้วนตอเนอื่ งตลอดเวลา ภายในฟง กชั่น น้จี ะมีโปรแกรมของผูใช เพอ่ื รับคาจากพอรต ประมวล แลว สงั่ เอาตพตุ ออกขาตางๆ เพอ่ื ควบคุมการ ทํางานของบอรด ตัวอยางที่ 1-2 int buttonPin = 3; // กาํ หนดช่ือตัวแปรใหข าพอรต 3 และชนิดของตวั แปร void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); } // ลปู ตรวจสอบการกดสวติ ชท ขี่ าพอรต ซงึ่ ถกู ประกาศดว ยตวั แปร buttonPin void loop() { if (digitalRead(buttonPin) == HIGH) serial.Write('H'); else Serial.write('L'); delay(1000); }

8    Arduino IDE 1.2 คาํ สงั่ ควบคมุ การทํางาน 1.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) หามเขียนผิดเปน = เชน if(x=10) คาํ สงั่ ทเ่ี ขยี นผดิ ในแบบนี้ ผลการทดสอบจะเปน จรงิ เสมอ เมอ่ื ผา นคาํ สง่ั นแี้ ลว x จะมคี า เทา กับ 10 ทําใหการทํางานของโปรแกรมผิดเพยี้ นไป ไมเ ปนตามท่ีกําหนดไว นอกจากนั้นยังใชคําสั่ง if ควบคุมการแยกเสนทางของโปรแกรม โดยใชคําสั่ง if...else ไดดวย

   Arduino IDE9 1.2.2 คาํ สงั่ if...else ใชทดสอบเพื่อกําหนดเงื่อนไขการทํางานของโปรแกรมไดมากกวาคําส่ัง if ธรรมดา โดย สามารถกาํ หนดไดว า ถา เงอื่ นไขเปน จรงิ ใหท าํ อะไร ถา เปน เทจ็ ใหท าํ อะไร เชน ถา คา อนิ พตุ อะนาลอก ที่อา นไดน อ ยกวา 500 ใหทําอะไร ถา คามากกวา หรอื เทา กับ 500 ใหทาํ อกี อยาง เขียนคําส่งั ไดด งั นี้ ตัวอยา งท่ี 1-3 if (pinFiveInput < 500) { // คาํ สง่ั เพอ่ื ทาํ งานอยา งหนง่ึ เนื่องมาจาก pinFiveInput มีคา นอยกวา 500 } else { // คาํ สง่ั เพอื่ ทาํ งานอีกอยา งหนงึ่ เน่ืองมาจาก pinFiveInput มีคา มากวาหรอื เทา กับ 500 } หลงั คาํ สง่ั else สามารถตามดว ยคาํ สง่ั if ทาํ ใหร ปู แบบคาํ สงั่ กลายเปน if...else...if เปน การทดสอบเง่อื นไขตา งๆ เม่ือเปน จรงิ ใหทําตามท่ีตองการ ดงั ตัวอยางตอไปน้ี ตัวอยา งที่ 1-4 if (pinFiveInput < 500) { // คาํ ส่ังเพื่อทาํ งานอยา งหนง่ึ เน่ืองมาจาก pinFiveInput มีคา นอยกวา 500 } else if (pinFiveInput >= 1000) { // คาํ สั่งเพื่อทาํ งานอกี อยา งหนงึ่ เน่ืองมาจาก pinFiveInput มีคา มากกวาหรอื เทา กับ 1000 } else { // คาํ สั่งเพือ่ กาํ หนดใหท าํ งานตอไปในกรณีที่ pinFiveInput ไมไ ดม ีคา นอยกวา 500 // และมากกวาหรอื เทา กับ 1000 (น่ันคือ จะมีการกระทําคาํ สงั่ ในโปรแกรมยอยนเี้ มอ่ื ตัวแปรมคี า อยู // ระหวา ง 501 ถึง 999 (ฐานสบิ ) } หลงั คาํ สง่ั else สามารถตามดว ยคาํ สง่ั if ไดไ มจ าํ กดั (หรอื ใชค าํ สงั่ switch case แทนคาํ สง่ั if...else...if สาํ หรบั การทดสอบเงอื่ นไขจาํ นวนมากๆ ได) เมอ่ื ใชคาํ สงั่ if...else แลว ตองกาํ หนดดว ยวา ถาทดสอบไมตรงกับเงอ่ื นไขใดๆ เลย ใหท าํ อะไร โดยใหก ําหนดที่คาํ สง่ั else ตัวสุดทาย

10      Arduino IDE 1.2.3 คาํ สงั่ for() คาํ สง่ั นใ้ี ชเ พอ่ื สง่ั ใหค าํ สง่ั ทอี่ ยภู ายในวงเลบ็ ปก กาหลงั for มกี ารทาํ งานซา้ํ กนั ตามจาํ นวนรอบ ทต่ี อ งการ คาํ สงั่ นมี้ ปี ระโยชนม ากสาํ หรบั การทาํ งานใดๆ ทต่ี อ งทาํ ซาํ้ กนั และทราบจาํ นวนรอบของการ ทาํ ซา้ํ ทแ่ี นน อนมกั ใชค กู บั ตวั แปรอะเรยใ นการเกบ็ สะสมคา ทอ่ี า นไดจ ากขาอนิ พตุ อะนาลอกหลายๆขาท่ี มหี มายเลขขาตอ เนอ่ื งกนั รูปแบบของคําส่ัง for() แบง ได 3 สวนดงั น้ี for (initialization; condition; increment) { //statement(s); } เร่ิมตนดวย initialization ใชกําหนดคาเร่ิมตนของตัวแปรควบคุมการวนรอบ ในการ ทํางานแตละรอบจะทดสอบ condition ถาเงื่อนไขเปนจริงจะกระทําคําส่ังในวงเล็บปกกา แลวมา เพิ่มหรือลดคาตัวแปรตามท่ีสั่งใน increment แลวทดสอบเงื่อนไขอีก ทําซ้ําจนกวาเง่ือนไขเปนเท็จ ตัวอยางท่ี 1-5 for (int i=1; i <= 8; i++) { // คาํ สั่งเพื่อทาํ งานโดยใชคา ของตวั แปร i และวนทํางานจนกระท่ังคา ของตวั แปร i มากกวา 8; } คําส่ัง for ของภาษา C จะยืดหยุนกวาคําส่ัง for ของภาษาคอมพิวเตอรอ นื่ ๆ โดยสามารถ ละเวนบางสวนหรือท้ังสามสวนของคําส่ัง for ได อยา งไรก็ตามยงั คงตองมเี ซมิโคลอน

   Arduino IDE11 1.2.4 คาํ สง่ั switch-case ใชทดสอบเงอ่ื นไขเพื่อกาํ หนดการทาํ งานของโปรแกรม ถา ตัวแปรทท่ี ดสอบตรงกับเงื่อนไข ใดก็ใหทํางานตามท่ีกําหนดไว พารามเิ ตอร var ตวั แปรทต่ี องการทดสอบวา ตรงกบั เงอ่ื นไขใด default ถาไมต รงกบั เงอื่ นไขใดๆ เลยใหท าํ คาํ ส่งั ตอ ทา ยน้ี break คาํ สงั่ หยดุ การทาํ งาน ใชเ ขยี นตอ ทา ย case ตา งๆ ถา ไมไ ดเ ขยี น โปรแกรมจะวนทาํ งานตามเงอ่ื นไข ตอ ไปเรอ่ื ยๆ ตัวอยางที่ 1-6 switch (var) { case 1: // คาํ สง่ั เพ่อื ทาํ งาน เมอ่ื คา ของตวั แปรเทา กับ 1 break; case 2: // คาํ สั่งเพ่อื ทาํ งาน เมอื่ คา ของตวั แปรเทา กับ 2 break; default: // ถา หากคาของตวั แปรไมใช 1 และ 2 ใหก ระทาํ คาํ สั่งในสว นน้ี }

12     Arduino IDE 1.2.5 คาํ สงั่ while เปน คาํ สงั่ วนรอบ โดยจะทาํ คาํ สงั่ ทเ่ี ขยี นในวงเลบ็ ปก กาอยา งตอ เนอ่ื ง จนกวา เงอื่ นไขในวงเลบ็ ของคําสง่ั while() จะเปน เทจ็ คาํ สง่ั ทใ่ี หท าํ ซา้ํ จะตอ งมกี ารเปลย่ี นแปลงคา ตวั แปรทใ่ี ชท ดสอบ เชน มกี ารเพมิ่ ตา ตวั แปรหรอื มเี งอ่ื นไขภายนอกเชน อา นคา จากเซน็ เซอรไ ดเ รยี บรอ ยแลว ใหห ยดุ การอา นคา มิ ฉะนนั้ เงอื่ นไขในวงเลบ็ ของ while() เปน จรงิ ตลอดเวลา ทาํ ใหค าํ สง่ั while ทาํ งานวนไมร จู บ รูปแบบคําส่ัง while(expression) { // statement(s); } พารามเิ ตอร expression เปน คําส่งั ทดสอบเงอื่ นไข (ถูกหรอื ผดิ ) ตัวอยา งที่ 1-7 var = 0; while(var < 200) { // คาํ สัง่ เพื่อทาํ งาน โดยวนทาํ งานทง้ั สน้ิ 200 รอบ var++; }

  Arduino IDE13 1.3 ตวั กระทาํ ทางคณติ ศาสตร ประกอบดวยตัวกระทาํ 5 ตัวคอื + (บวก), - (ลบ), * (คณู ), / (หาร) และ % (หารเอาเศษ) 1.3.1 ตวั กระทาํ ทางคณติ ศาสตร บวก ลบ คณู และหาร ใชห าคา ผลรวม ผลตา ง ผลคณู และผลหารคา ของตวั ถกู กระทาํ สองตวั โดยใหค าํ ตอบมปี ระเภทตรงกบั ตวั ถูกกระทาํ ทั้งสองตวั เชน 9/4 ใหคาํ ตอบเทากับ 2 เนอื่ งจากท้ัง 9 และ 4 เปนตัวแปรเลขจาํ นวนเต็ม (int) นอกจากนต้ี วั กระทาํ ทางคณติ ศาสตรอ าจทาํ ใหเ กดิ โอเวอรโ ฟลว (overflow) ถา ผลลพั ธท ไี่ ดม ขี นาดใหญเ กนิ กวา จะสามารถเกบ็ ในตวั แปรประเภทนนั้ ถา ตวั ทถี่ กู กระทาํ ตา งประเภทกนั ผลลพั ธไ ดเ ปน จะมขี นาดใหญข นึ้ เทา กบั ประเภทของตวั แปรทใ่ี หญท สี่ ดุ (เชน 9/4 = 2 หรอื 9/3.0 = 2.25) รูปแบบคําสงั่ result = value1 + value2; result = value1 - value2; result = value1 * value2; result = value1 / value2; พารามเิ ตอร value1 : เปน คาของตวั แปรหรอื คา คงทใ่ี ดๆ value2: เปน คาของตวั แปรหรอื คา คงทใ่ี ดๆ ตัวอยา งท่ี 1-8 y = y + 3; x = x - 7; i = j * 6; r = r / 5; เทคนคิ สาํ หรับการเขียนโปรแกรม  เลือกขนาดของตัวแปรใหใ หญพอสําหรบั เก็บคาผลลัพธท ม่ี ากท่ีสุดของการคํานวณ  ตอ งทราบวา ทค่ี า ใดตวั แปรทเ่ี กบ็ จะมกี ารวนซา้ํ คา กลบั และวนกลบั อยา งไร ตวั อยา งเชน (0 ไป 1) หรอื (0 ไป -32768)  สาํ หรบั การคาํ ณวณทตี่ อ งการเศษสว นใหใ ชต วั แปรประเภท float แตใ หร ะวงั ผลลบ เชน ตัวแปรมขี นาดใหญ คํานวณไดช า  ใชต วั กระทาํ cast เชน (int)myfloat ในการเปลย่ี นประเภทของตวั แปรชว่ั คราวขณะ ทโ่ี ปรแกรมทาํ งาน

14     Arduino IDE 1.3.2 ตวั กระทาํ % หารเอาเศษ ใชหาคาเศษที่ไดข องการหารเลขจาํ นวนเต็ม 2 ตัว ตัวกระทาํ หารเอาเศษไมส ามารถใชงานกับ ตัวแปรเลขทศนิยม (float) รูปแบบคําสงั่ result = value1 % value2; พารามเิ ตอร value1 - เปน ตัวแปรประเภท byte,char,int หรอื long value2 - เปน ตัวแปรประเภท byte,char,int หรอื long ผลท่ีได เศษจากการหารคา เลขจาํ นวนเตม็ เปน ขอ มลู ชนดิ เลขจาํ นวนเตม็ ตัวอยางที่ 1-9 // x now contains 2 // x now contains 4 x = 7 % 5; // x now contains 0 x = 9 % 5; x = 5 % 5; // x now contains 4 x = 4 % 5; ตัวกระทําหารเอาเศษน้ีมักนําไปใชในงานที่ตองการใหเหตุการณเกิดข้ึนดวยชวงเวลาท่ีสม่ํา เสมอ หรอื ใชท ําใหหนว ยความทเี่ กบ็ ตัวแปรอะเรยเกิดการลนคากลับ (roll over) ตัวอยา งที่ 1-10 // ตรวจสอบคาของตวั ตรวจจับ 10 ครงั้ ตอ การทาํ งาน 1 รอบ void loop() { i++; if ((i % 10) == 0) // หารคา ของ i ดว ย 10 แลว ตรวจสอบเศษการหารเปน 0 หรอื ไม { x = analogRead(sensPin); // อานคาจากตวั ตรวจจบั 10 ครงั้ } } ในตวั อยา งน้ีเปน การนําคาํ สัง่ % มาใชกาํ หนดรอบของการทาํ งาน โดยโปรแกรมวนทํางานเพอ่ื อานคาจนกวา ผลการหารเอาเศษของคาํ สัง่ i % 10 จะเทากับ 0 ซง่ึ จะเกิดขน้ึ เม่ือ i = 10 เทา น้ัน

  Arduino IDE15 1.4 ตวั กระทําเปรยี บเทยี บ ใชประกอบกับคําสั่ง if() เพอ่ื ทดสอบเงอ่ื นไขหรือเปรยี บเทยี บคาตัวแปรตา ง โดยจะเขียน เปนนพิ จนอ ยภู ายในเครอ่ื งหมาย () x == y (x เทากบั y) x != y (x ไมเทา กบั y) x < y (x นอยกวา y) x > y (x มากกวา y) x <= y (x นอ ยกวาหรอื เทา กับ y) x >= y (x มากกวา หรอื เทา กบั y) 1.5 ตวั กระทาํ ทางตรรกะ ใชในการเปรียบเทียบของคาํ สง่ั if()มี 3 ตัวคือ &&, || และ ! 1.5.1 && (ตรรกะ และ) ใหคาเปนจริงเมื่อผลการเปรียบเทียบท้ังสองขางเปนจริงทั้งคู ตัวอยา งท่ี 1-11 if (x > 0 && x < 5) { // ... } ใหค า เปน จรงิ เมอ่ื x มากกวา 0 และนอ ยกวา 5 (มีคา 1 ถึง 4) 1.5.2 && (ตรรกะ หรอื ) ใหคาเปนจริง เมื่อผลการเปรียบเทียบพบวา มีตัวแปรตัวใดตัวหน่ึงเปนจรงิ หรือเปนจริงทงั้ คู ตัวอยางท่ี 1-12 if (x > 0 || y > 0) { // ... } ใหผ ลเปน จรงิ เมอ่ื x หรอื y มีคา มากกวา 0

16     Arduino IDE 1.5.3 ! (ใชกลับผลเปนตรงกันขาม) ใหคาเปนจรงิ เม่ือผลการเปรียบเทียบเปนเท็จ ตัวอยา งที่ 1-13 if (!x) { // ... } ใหผ ลเปน จริงถา x เปน เทจ็ (เชน ถา x = 0 ใหผ ลเปน จรงิ ) 1.5.4 ขอ ควรระวัง ระวังเรื่องการเขียนโปรแกรม ถาตองการใชตัวกระทําตรรกะและ ตองเขียนเครื่องหมาย && ถาลืมเขียนเปน & จะเปนตัวกระทําและระดับบิตกับตัวแปร ซึ่งใหผลท่ีแตกตาง เชนกันในการใชตรรกะหรือใหเขียนเปน || (ขีดต้ังสองตัวติดกัน) ถาเขียนเปน | (ขีดต้ังตัว เดียว) จะหมายถึงตัวกระทําหรือระดับบิตกับตัวแปร ตัวกระทํา NOT ระดบั บติ (~) จะแตกตางจากตวั กลบั ผลใหเ ปนตรงขาม (!) ตองเลอื กใชให ถูกตอง ตัวอยา งที่ 1-14 if (a >= 10 && a <= 20){} // ใหผ ลการทาํ งานเปน จรงิ เมอ่ื a มีคา อยูระหวา ง 10 ถึง 20

   Arduino IDE17 1.6 ตวั กระทําระดบั บติ ตัวกระทําระดับจะนําบิตของตัวแปรมาประมวลผล ใชประโยชนในการแกปญหาดานการ เขียนโปรแกรมไดหลากหลาย ตัวกระทําระดับของภาษาซี (ซ่ึงรวมถึง Arduino) มี 6 ตัวไดแ ก & (bitwise AND), | (OR), ^ (Exclusive OR), ~ (NOT), << (เลอื่ นบติ ไปทางขวา) และ >> (เลอ่ื นบติ ไป ทางซาย) 1.6.1 ตวั กระทําระดับบิต AND (&) คําส่ัง AND ในระดับบิตของภาษาซีเขียนไดโ ดยใช & หนงึ่ ตัว โดยตองเขียนระหวา งนิพจน หรอื ตวั แปรทเี่ ปน เลขจาํ นวนเตม็ การทาํ งานจะนาํ ขอ มลู แตล ะบติ ของตวั แปรทงั้ สองตวั มากระทาํ ทาง ตรรกะ AND โดยมกี ฎดังน้ี ถาอนิ พตุ ท้ังสองตัวเปน “1” ท้งั คูเอาตพตุ เปน “1” กรณอี น่ื ๆ เอาตพตุ เปน “0” ดงั ตัวอยางตอ ไปนี้ ในการดใู หคูของตัวกระทําตามแนวตั้ง 0 0 1 1 Operand1 0 1 0 1 Operand2 —————————— 0 0 0 1 Returned result ใน Arduino ตัวแปรประเภท int จะมีขนาด 16 บิต ดังนนั้ เม่ือใชต ัวกระทําระดบั บิต AND จะมี การกระทาํ ตรรกะและพรอมกนั กับขอมลู ทงั้ 16 บิต ดงั ตัวอยางในสวนของโปรแกรมตอไปนี้ ตัวอยา งท่ี 1-15 int a = 92; // เทา กับ 0000000001011100 ฐานสอง int b = 101; // เทา กับ 0000000001100101 ฐานสอง int c = a & b; // ผลลพั ธค อื 0000000001000100 ฐานสองหรอื 68 ฐานสบิ ในตวั อยา งน้ีจะนําขอ มูลทงั้ 16 บิตของตวั แปร a และ b มากระทําทางตรรกะ AND แลว นําผลลพั ธท ไี่ ดทงั้ 16 บิตไปเกบ็ ที่ตัวแปร c ซง่ึ ไดค า เปน 01000100 ในเลขฐานสองหรอื เทา กับ 68 ฐานสบิ นยิ มใชต ัวกระทาํ ระดบั บิต AND เพอื่ ใชเลือกขอมลู บิตท่ีตองการ (อาจเปน หนง่ึ บติ หรือหลาย บิต) จากตัวแปร int ซ่ึงการเลือกเพยี งบางบิตนี้จะเรียกวา masking

18     Arduino IDE 1.6.2 ตวั กระทาํ ระดับบิต OR (|) คําส่ังระดับบิต OR ของภาษาซีเขียนไดโดยใชเครื่องหมาย |หนึ่งตัว โดยตองเขียนระหวาง นิพจนหรือตัวแปรท่ีเปนเลขจํานวนเต็ม สําหรับการทํางานใหนําขอมูลแตละบิตของตัวแปรทั้งสอง ตัวมากระทําทางตรรกะ OR โดยมีกฎดังน้ี ถา อนิ พตุ ตวั ใดตวั หนง่ึ หรอื ทง้ั สองตวั เปน “1” เอาตพ ตุ เปน “1” กรณที อี่ นิ พตุ เปน “0” ทงั้ คู เอาตพ ตุ จงึ จะเปน “0” ดงั ตวั อยา งตอ ไปนี้ 0 0 1 1 Operand1 0 1 0 1 Operand2 —————————— 0 1 1 1 Returned result ตัวอยา งท่ี 1-16 สว นของโปรแกรมแสดงการใชต วั กระทาํ ระดบั บติ OR int a = 92; // เทา กับ 0000000001011100 ฐานสอง int b = 101; // เทา กับ 0000000001100101 ฐานสอง int c = a | b; // ผลลพั ธค อื 0000000001111101 ฐานสอง หรอื 125 ฐานสบิ ตัวอยา งที่ 1-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() กอ น) ดงั นน้ั ถากําหนดคาให PORTD = B00110001; กค็ อื ตองการใหข า 2,3 และ 7 เปน HIGH ในกรณีน้ีไมต องเปลย่ี นคา สถานะของขา 0 และ 1 ซง่ึ ปกตแิ ลว ฮารด แวรข อง Arduino ใชใ นการสอ่ื สารแบบอนกุ รม ถา ไปเปลยี่ นคา แลว จะกระทบ ตอการสือ่ สารแบบอนุกรม อัลกอริธมึ สาํ หรบั โปรแกรมเปนดงั น้ี  อา นคาจาก PORTD แลวลา งคา เฉพาะบิตทต่ี องการควบคุม (ใชตัวกระทําแบบบิต AND)  นําคา PORTD ทแี่ กไ ขจากขา งตน มารวมกับคาบิตทตี่ องการควบคุม (ใชตัวกระทําแบบบิต OR) เขียนเปน โปรแกรมไดด ังน้ี

  Arduino IDE19 int i; // counter variable int j; void setup() { DDRD = DDRD | B11111100; // กาํ หนดทศิ ทางของขาพอรต 2 ถึง 7 ดว ยคา 11111100 Serial.begin(9600); } void loop() { for (i=0; i<64; i++) { PORTD = PORTD & B00000011; // กาํ หนดขอ มูลไปยังขาพอรต 2 ถึง 7 j = (i << 2); PORTD = PORTD | j; Serial.println(PORTD, BIN); // แสดงคา ของ PORTD ทห่ี นาตาง Serial montior delay(100); } } 1.6.3 คาํ สง่ั ระดบั บิต Exclusive OR (^) เปน โอเปอรเ ตอรพ เิ ศษทไี่ มค อ ยไดใ ชใ นภาษา C/C++ ตวั กระทาํ ระดบั บติ exclusive OR (หรอื XOR) จะเขยี นโดยใชส ัญลกั ษณเ คร่ืองหมาย ^ ตัวกระทาํ นมี้ ีการทํางานใกลเ คียงกบั ตัวกระทําระดับ บิต OR แตตางกันเม่ืออินพตุ เปน “1” ทั้งคูจะใหเ อาตพตุ เปน “0” แสดงการทํางานไดด ังนี้ 0 0 1 1 Operand1 0 1 0 1 Operand2 —————————— 0 1 1 0 Returned result หรอื กลาวไดอกี อยางวา ตัวกระทําระดบั บติ XOR จะใหเ อาตพ ตุ เปน “0” เมื่ออินพตุ ทั้งสอง ตัวมคี าเหมือนกัน และใหเอาตพตุ เปน “1” เมื่ออินพตุ ทั้งสองมคี าตางกัน ตัวอยา งที่ 1-18 int x = 12; // คา เลขฐานสองเทา กับ 1100 int y = 10; // คา เลขฐานสองเทากับ 1010 int z = x ^ y; // ผลลพั ธเ ทา กับ 0110 ฐานสองหรือ 6 ฐานสิบ ตวั กระทาํ ระดบั บติ XOR จะใชม ากในการสลบั คา บางบติ ของตวั ตวั แปร int เชน กลบั จาก “0” เปน “1” หรอื กลับจาก “1” เปน “0” เมื่อใชตัวกระทําระดับบติ XOR ถา บิตของ mask เปน “1” ทาํ ใหบติ น้ันถกู สลับคา ถา mask มีคาเปน “1” บติ น้ันมีคาคงเดิม ตัวอยางตอไปน้เี ปนโปรแกรมแสดงการสั่งใหขาดิจติ อล 5 มกี ารกลบั ลอจิกตลอดเวลา

20     Arduino IDE ตัวอยา งที่ 1-19 // กาํ หนดขา 5 เปน เอาตพตุ // กลบั ลอจกิ ทข่ี า 5 void setup() { DDRD = DDRD | B00100000; } void loop() { PORTD = PORTD ^ B00100000; delay(100); } 1.6.4 ตวั กระทาํ ระดับบิต NOT (~) ตัวกระทําระดับบิต NOT จะเขียนโดยใชสัญลักษณเครื่องหมาย ~ ตัวกระทาํ นจ้ี ะใชงานกับ ตัวถกู กระทําเพยี งตวั เดยี วทอ่ี ยขู วามอื โดยทาํ การสลับบติ ทุกบิตใหม คี าตรงกันขามคือ จาก “0” เปน “1” และจาก “1” เปน “0” ดังตัวอยาง 01 Operand1 ————— ~ Operand1 10 int a = 103; // binary: 0000000001100111 int b = ~a; // binary: 1111111110011000 เมอ่ื กระทาํ แลว ทาํ ใหต วั แปร b มคี า -104 (ฐานสบิ ) ซงึ่ คําตอบทไี่ ดต ดิ ลบเนอื่ งจากบติ ทมี่ คี วาม สาํ คัญสงู สุด (บิตซายมือสดุ ) ของตัวแปร int อนั เปนบิตแจงวา ตัวเลขเปนบวกหรอื ลบ มีคาเปน “1” แสดงวา คา ทไ่ี ดน ตี้ ดิ ลบ โดยในคอมพวิ เตอรจ ะเกบ็ คา ตวั เลขทงั้ บวกและลบตามระบบทคู อมพลเี มนต (2’s complement) การประกาศตวั แปร int ซง่ึ มคี วามหมายเหมอื นกบั การประกาศตวั แปรเปน signed int ตอ งระวงั คาของตัวแปรจะติดลบได

   Arduino IDE21 1.6.5 คาํ สงั่ เลอื่ นบติ ไปทางซา ย (<<) และเลอื่ นบติ ไปทางขวา (>>) ในภาษา C/C++ มีตัวกระทําเล่ือนบติ ไปทางซาย << และเล่ือนบิตไปทางขวา >> ตัวกระทาํ นี้จะส่ังเลอ่ื นบติ ของตวั ถกู กระทําทเ่ี ขียนดานซายมือไปทางซา ยหรอื ไปทางขวาตามจํานวนบติ ที่ระบุ ไวในดานขวามือของตัวกระทํา รูปแบบคําสง่ั variable << number_of_bits variable >> number_of_bits พารามเิ ตอร variable เปน ตัวแปรเลขจํานวนเต็มที่มีจํานวนบิตนอยกวาหรอื เทา กับ 32 บิต (หรอื ตัวแปรประเภท byte, int หรอื long) ตัวอยางท่ี 1-20 int a = 5; // เทา กับ 0000000000000101 ฐานสอง int b = a << 3; // ไดผ ลลพั ธเ ปน 0000000000101000 ฐานสองหรอื 40 int c = b >> 3; // ไดผลลพั ธเ ปน 0000000000000101 ฐานสองหรือ 5 ฐานสบิ ตัวอยางที่ 1-21 เมื่อสั่งเลื่อนคาตัวแปร x ไปทางซายจํานวน y บิต (x << y) บิตขอมูลที่อยูดานซายสุดของ x จํานวน y ตัวจะหายไปเนื่องจากถูกเลื่อนหายไปทางซายมือ int a = 5; // เทา กับ 0000000000000101ฐานสอง int b = a << 14; // ไดผลลพั ธเ ปน 0100000000000000 ฐานสอง การเลื่อนบิตไปทางซาย จะทําใหคาของตัวแปรดานซายมือของตัวกระทําจะถูกคูณดวยคา สองยกกําลังบิตท่ีเล่อื นไปทางซายมือ ดังน้ี 1 << 0 == 1 1 << 1 == 2 1 << 2 == 4 1 << 3 == 8 ... 1 << 8 == 256 1 << 9 == 512 1 << 10 == 1024 ...

22     Arduino IDE เมอื่ สง่ั เลอื่ นตวั แปร x ไปทางขวามอื จาํ นวน y บติ (x >> y) จะมผี ลแตกตา งกนั ขนึ้ กบั ประเภท ของตวั แปร ถา x เปน ตวั แปรประเภท int คา ทเี่ กบ็ ไดม ที งั้ คา บวกและลบ โดยบติ ซา ยมอื สดุ จะเปน sign bit หรอื บติ เครอ่ื งหมาย ถา เปน คา ลบ คา บติ ซา ยมอื สดุ จะมคี า เปน 1 กรณนี เ้ี มอ่ื สงั่ เลอ่ื นบติ ไปทางขวามอื แลว โปรแกรมจะนาํ คา ของบติ เครอื่ งหมายมาเตมิ ใหก บั บติ ทางซา ยมอื สดุ ปรากฏการณน เี้ รยี กวา sign extension มตี วั อยา งดงั นี้ ตัวอยา งที่ 1-22 int x = -16; // เทา กับ 1111111111110000 ฐานสอง int y = x >> 3; // เลอื่ นบติ ของตวั แปร x ไปทางขวา 3 ครง้ั // ไดผ ลลพั ธเ ปน 1111111111111110 ฐานสอง ถา ตอ งการเลอื่ นบติ ไปทางขวามอื แลว ใหค า 0 มาเตมิ ยงั บติ ซา ยมอื สดุ (ซง่ึ เกดิ กบั กรณที ต่ี วั แปร เปนประเภท unsigned int) ทาํ ไดโ ดยใชการเปล่ียนประเภทตัวแปรชว่ั คราว (typecast) เพอื่ เปลยี่ นให ตัวแปร x เปน unsigned int ชัว่ คราวดงั ตัวอยางตอไปน้ี ตัวอยา งที่ 1-23 // เทา กับ 1111111111110000 ฐานสอง // เลอ่ื นบิตของตวั แปร x (แบบไมค ดิ เครอ่ื งหมาย) ไปทางขวา 3 ครงั้ int x = -16; int y = unsigned(x) >> 3; // ไดผ ลลพั ธเ ปน 0001111111111110 ฐานสอง ถาหากระมัดระวงั เรอ่ื ง sign extension แลว ก็จะใชตัวกระทําเลื่อนบติ ไปทางขวามอื สาํ หรบั หารคา ตัวแปรดว ย 2 ยกกําลงั ตางๆ ไดด ังตัวอยาง ตัวอยา งท่ี 1-24 // หารคา ของ 1000 ดว ย 8 (มาจาก 23) ทาํ ให y = 125 int x = 1000; int y = x >> 3;

   Arduino IDE23 1.7 ไวยากรณภ าษาของ Arduino 1.7.1 ; (เซมิโคลอน - semicolon) ใชเขียนแจงวา จบคําส่ัง ตัวอยางที่ 1-25 int a = 13; บรรทัดคําส่ังที่ลืมเขียนปดทายดวยเซมิโคลอน จะทําใหแปลโปรแกรมไมผาน โดยตัวแปร ภาษาอาจจะแจง ใหทราบวา ไมพ บเครอ่ื งหมายเซมิโคลอน หรอื แจงเปนการผิดพลาดอ่ืนๆ บางกรณี ท่ีตรวจสอบบรรทัดที่แจงวาเกิดการผิดพลาดแลวไมพบท่ีผิด ใหตรวจสอบบรรทัดกอนหนานั้น 1.7.2 { } (วงเล็บปกกา - curly brace) เคร่ืองหมายวงเล็บปกกา เปนสวนสาํ คัญของภาษาซี ใชในการกําหนดขอบเขตการทาํ งานใน แตละชวง วงเล็บปกกาเปด { จะตอ งเขียนตามดวยวงเล็บปกกาปด } ดว ยเสมอ หรือเรยี กวา วงเล็บตอง ครบคู ในซอฟตแ วร Arduino IDE ท่ีใชเขียนโปรแกรมจะมคี วามสามารถในการตรวจสอบการครบ คูของเครอื่ งหมายวงเล็บ ผูใชงานเพยี งแคคลิกท่ีวงเลบ็ มนั จะแสดงวงเลบ็ ท่เี หลือซง่ึ เปนคูของมนั สาํ หรบั โปรแกรมเมอรม อื ใหมแ ละโปรแกรมเมอรท ่ียายจากภาษา BASIC มาเปนภาษา C มกั จะสบั สนกบั การใชเ ครอ่ื งหมายวงเลบ็ แทท จ่ี รงิ แลว เครอื่ งหมายปก กาปด นเี้ ทยี บไดก บั คาํ สง่ั RETURN ของ subroutine (function) หรอื แทนคําสงั่ ENDIF ในการเปรยี บเทียบ และแทนคาํ ส่ัง NEXT ของคาํ สั่งวนรอบ FOR เนอ่ื งจากมกี ารใชว งเลบ็ ปก กาไดห ลากหลาย ดงั นนั้ เมอ่ื ตอ งการเขยี นคาํ สง่ั ทต่ี อ งใชเ ครอื่ งหมาย วงเล็บ เม่ือเขียนวงเล็บเปดแลวใหเขียนเครื่องหมายวงเล็บปดทันที ถัดมาจึงคอยเคาะปุม Enter ใน ระหวา งเครอื่ งหมายวงเลบ็ เพอื่ ขน้ึ บรรทดั ใหม แลว เขยี นคาํ สง่ั ทตี่ อ งการ ถา ทาํ ไดต ามนวี้ งเลบ็ จะครบ คูแนนอน สาํ หรบั วงเลบ็ ทไี่ มค รบคูทาํ ใหเ กดิ ความผดิ พลาดในขณะคอมไพลโ ปรแกรม ถา เปน โปรแกรม ขนาดใหญจะหาที่ผิดไดยาก ตําแหนงท่ีอยูของเครื่องหมายวงเล็บแตละตัวจะมีผลอยางมากตอ ไวยากรณของภาษาคอมพิวเตอร การยายตําแหนงวงเล็บไปเพียงหน่ึงหรือสองบรรทัด ทําใหตัว โปรแกรมทํางานผิดไป

24     Arduino IDE ตําแหนงที่ใชวงเล็บปกกา ฟง กช ่ัน (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) } คาํ สงั่ ทดสอบเงอื่ นไข (condition) if (boolean expression) { statement(s) } else if (boolean expression) { statement(s) } else { statement(s) } 1.7.3 // และ /*...* หมายเหตบุ รรทดั เดยี วและหลายบรรทัด เปน สว นของโปรแกรมทผี่ ใู ชเ ขยี นเพมิ่ เตมิ วา โปรแกรมทาํ งานอยา งไร โดยสว นทเ่ี ปน หมายเหตุ จะไมถ กู คอมไพล ไมน าํ ไปประมวลผล มปี ระโยชนม ากสาํ หรบั การตรวจสอบโปรแกรมภายหลงั หรอื ใชแ จง ใหเ พอ่ื นรว มงานหรอื บคุ คลอน่ื ทราบวา บรรทดั นใี้ ชท าํ อะไร ตวั หมายเหตภุ าษาซมี ี 2 ประเภทคอื (1) หมายเหตุบรรรทดั เดียว เขียนเครื่องสแลช // 2 ตัวหนา บรรทดั (2) หมายเหตหุ ลายบรรทดั เขยี นเครอ่ื งหมายสแลช / คกู บั ดอกจนั * ครอ มขอ ความทเี่ ปน หมายเหตุ เชน /* blabla */

  Arduino IDE25 1.7.4 #define เปนคําสั่งท่ีใชงานมากในการกําหนดคาคงที่ใหกับโปรแกรม เน่ืองจากเปนการกําหนดคาท่ี ไมใ ชพ นื้ ทห่ี นว ยความจาํ ของไมโครคอนโทรลเลอรแ ตอ ยา งใด เมอื่ ถงึ ขนั้ ตอนแปลภาษา คอมไพเลอร จะแทนที่ตัวอักษรดวยคาที่กําหนดไว ใน Arduino จะใช คําส่ัง #define ตรงกบั ภาษา C รูปแบบ #define constantName value อยาลืมเครื่องหมาย # ตัวอยา งที่ 1-26 #define ledPin 3 // เปน การกาํ หนดใหต ัวแปร ledPin เทา กับคาคงที่ 3 ทายคาํ สง่ั #define ไมต องมเี ครื่องหมายเซมโิ คลอน 1.7.5 #include ใชส่ังใหรวมไฟลอ น่ื ๆ เขากับไฟลโ ปรแกรมของเรากอน แลว จงึ ทําการคอมไพลโ ปรแกรม รูปแบบคําสง่ั #include <file> #include “file” ตัวอยา งท่ี 1-27 #include <stdio.h> #include “popx2.h” บรรทัดแรกจะส่ังใหเรียกไฟล stdio.h มารวมกับไฟลโปรแกรมท่ีกําลังพัฒนา โดยคนหาไฟล จากตาํ แหนง ที่เก็บไฟลระบบของ Arduino โดยปกติเปนไฟลม าตรฐานที่มาพรอ มกับ Arduino บรรทัดท่ี 2 ส่ังใหรวมไฟล popx2.h มารวมกับไฟลโปรแกรมทีก่ ําลงั พัฒนา โดยหาไฟลจาก โฟลเดอรท ี่อยูของไฟลภ าษา C กอน ปกตเิ ปน ไฟลท ี่ผใู ชส รา งขน้ึ เอง

26    Arduino IDE 1.8 ตวั แปร ตวั แปรเปน ตวั อกั ษรหลายตวั ๆ ทกี่ าํ หนดขน้ึ ในโปรแกรมเพอื่ ใชใ นการเกบ็ คา ขอ มลู ตา งๆ เชน คาทีอ่ า นไดจ ากตวั ตรวจจบั ทต่ี ออยูกับขาพอรต อะนาลอกของ Arduino ตัวแปรมหี ลายประเภทดงั น้ี 1.8.1 char : ตวั แปรประเภทตัวอักขระ เปนตัวแปรทม่ี ขี นาด 1 ไบต (8 บิต) มีไวเ พอ่ื เก็บคาตัวอักษร ตัวอักษรในภาษา C จะเขยี นอ ยูในเครื่องหมายคําพูดขีดเดียว เชน ‘A’ (สาํ หรับขอความ ท่ปี ระกอบจากตัวอกั ษรหลายตัวเขียนตอ กันจะเขียนอยูใ นเครอื่ งหมายคําพดู ปกติ เชน “ABC”) คุณสามารถสั่งกระทําทางคณติ ศาสตรก ับตัว อกั ษรได ในกรณีจะนําคารหสั ASCII ของตัวอกั ษรมาใช เชน ‘A’ +1 มคี าเทากับ 66 เนื่องจากคา รหสั ASCII ของตัวอกั ษร A เทากับ 65 รูปแบบคําสง่ั char sign = ' '; ตัวอยางท่ี 1-28 char var = 'x'; var คอื ช่ือของตวั แปรประเภท char ทต่ี องการ x คอื คา ทต่ี อ งการกาํ หนดใหก บั ตัวแปร ในที่นเี้ ปน ตัวอกั ษรหนึ่งตัว 1.8.2 byte : ตวั แปรประเภทตัวเลข 8 บิตหรือ 1 ไบต ตัวแปร byte ใชเก็บคาตัวเลขขนาด 8 บิต มคี าไดจาก 0 - 255 ตัวอยางท่ี 1-29 byte b = B10010; // แสดงคา ของ b ในรปู ของเลขฐานสอง (เทา กับ 18 เลขฐานสบิ ) 1.8.3 int : ตวั แปรประเภทตัวเลขจาํ นวนเตม็ ยอจาก interger ซ่ึงแปลวา เลขจํานวนเต็ม int เปนตัวแปรพน้ื ฐานสําหรบั เก็บตัวเลข ตัวแปร หนงึ่ ตัวมีขนาด 2 ไบต เก็บคาไดจาก -32,768 ถึง 32,767 ซึ่งมาจาก -215 (คาต่ําสดุ ) และ 215- 1 (คาสงู สุด) ในการเก็บคาตัวเลขติดลบใชเทคนิคที่เรียกวา ทคู อมพลีเมนต (2’s complement) บิตสูงสดุ บาง ครั้งเรยี กวา บิตเครอ่ื งหมาย หรอื sign bit ถามีคาเปน “1” แสดงวา เปนคาติดลบ รูปแบบคําสงั่ int var = val; พารามเิ ตอร var คอื ชื่อของตวั แปรประเภท int ทต่ี องการ val คอื คา ท่ีตองการกาํ หนดใหก บั ตัวแปร

  Arduino IDE27 ตัวอยางท่ี 1-30 int ledPin = 13; // กาํ หนดใหต ัวแปร ledPIn มีคา เทา กับ 13 เม่ือตัวแปรมีคามากกวาคาสูงสดุ ที่เกบ็ ได จะเกิดการ “ลนกลบั ” (roll over) ไปยังคาตํ่าสุดที่ เก็บได และเม่ือมีคานอยกวาคาต่ําสุดท่ีเก็บไดจะลนกลับไปยังคาสูงสุด ดังตัวอยางตอไปนี้ ตัวอยา งท่ี 1-31 int x x = -32,768; x = x - 1; // เมื่อกระทาํ คาํ สัง่ แลว คา ของ x จะเปลยี่ นจาก -32,768 เปน 32,767 x = 32,767; x = x + 1; // เม่ือกระทาํ คาํ ส่งั แลว คา ของ x จะเปลยี่ นจาก 32,767 เปน -32,768 1.8.4 unsigned int : ตวั แปรประเภทเลขจาํ นวนเตม็ ไมค ดิ เครอ่ื งหมาย ตัวแปรประเภทนคี้ ลายกับตัวแปร int แตจะเก็บเลขจํานวนเต็มบวกเทานั้น โดยเกบ็ คา 0 ถงึ 65,535 (216 -1) รูปแบบคําสงั่ unsigned int var = val; พารามเิ ตอร var คอื ช่ือของตวั แปร int ทตี่ องการ val คอื คา ที่ตองการกาํ หนดใหก บั ตัวแปร ตัวอยา งท่ี 1-32 unsigned int ledPin = 13; // กาํ หนดใหต ัวแปร ledPIn มคี า เทา กับ 13 แบบไมคดิ เครอ่ื งหมาย เม่ือตัวแปรมีคาสงู สดุ จะลนกลับไปคาต่ําสุดหากมีการเพิ่มคาตอไป และเม่ือมคี าต่ําสดุ จะลน กลับเปนคาสงู สุดเม่ือมกี ารลดคาตอไปอกี ดงั ตัวอยาง ตัวอยา งท่ี 1-33 unsigned int x xx == x0;- 1; // เมอ่ื กระทาํ คาํ สง่ั แลว คา ของ x จะเปลย่ี นจาก 0 เปน 65535 x = x + 1; // เมอ่ื กระทาํ คาํ ส่ังแลว คา ของ x จะเปลยี่ นจาก 65535 กลบั ไปเปน 0

28     Arduino IDE 1.8.5 long : ตวั แปรประเภทเลขจาํ นวนเตม็ 32 บิต เปนตัวแปรเก็บคาเลขจํานวนเต็มทข่ี ยายความจเุ พม่ิ จากตัวแปร int โดยตัวแปร long หนง่ึ ตัว กินพน้ื ทหี่ นว ยความจํา 32 บิต (4 ไบต) เก็บคาไดจาก -2,147,483,648 ถึง 2,147,483,647 รูปแบบคําสงั่ long var = val; พารามเิ ตอร var คอื ชื่อของตวั แปร long ทตี่ องการ val คอื คา ที่ตองการกาํ หนดใหก บั ตัวแปร ตัวอยางที่ 1-34 // กาํ หนดใหต ัวแปร time เปน แบบ long long time; 1.8.6 unsigned long : ตวั แปรประเภทเลขจาํ นวนเตม็ 32 บติ แบบไมค ดิ เครอ่ื งหมาย เปนตัวแปรเก็บคาเลขจํานวนเต็มบวก ตัวแปรหนง่ึ ตัวกนิ พน้ื ทห่ี นว ยความจาํ 32 บิต (4 ไบต) เกบ็ คาไดจ าก 0 ถงึ 4,294,967,295 หรอื 232-1 รูปแบบคําสงั่ unsigned long var = val; พารามเิ ตอร var คอื ชื่อของตวั แปร unsigned long ทต่ี องการ val คอื คา ที่ตองการกาํ หนดใหก บั ตัวแปร ตัวอยา งท่ี 1-35 unsigned long time; // กาํ หนดใหต ัวแปร time เปน แบบ undigned long (ไมค ดิ เครอ่ื งหมาย)

  Arduino IDE29 1.8.7 float : ตวั แปรประเภทเลขทศนยิ ม เปนตัวแปรสาํ หรบั เก็บคาเลขเลขทศนิยม ซงึ่ นยิ มใชใ นการเก็บคาสัญญาณอะนาลอ็ กหรอื คา ทต่ี อเน่ือง เนื่องจากสามารถเก็บคาไดละเอยี ดกวา ตัวแปร int ตัวแปร float เก็บคาไดจ าก -4.4028235 x 1038 ถึง 4.4028235 x 1038 โดยหนงึ่ ตัวจะกินพน้ื ทหี่ นว ยความจาํ 32 บติ (4 ไบต) ในการคํานวณคณิตศาสตรกับตัวแปร float จะชากวาการคํานวณของตัวแปร int ดังนั้นจึง พยายามหลกี เลย่ี งการคาํ นวณกบั ตวั แปร float ในกรณกี ระทาํ คาํ สงั่ วนรอบทต่ี อ งทาํ งานดว ยความเรว็ สูงสุดของฟงกช่ันทางเวลาท่ีตองแมนยําอยางมาก โปรแกรมเมอรบางคนจะทําการแปลงตัวเลข ทศนิยมใหเ ปนเลขจํานวนเต็มกอนแลวจึงคํานวณเพ่ือใหทาํ งานไดเ รว็ ขน้ึ รูปแบบคําส่ัง float var = val; พารามเิ ตอร var คอื ชื่อของตวั แปร float ทต่ี องการ val คอื คา ที่ตองการกาํ หนดใหก บั ตัวแปร ตัวอยา งที่ 1-36 float myfloat; float sensorCalbrate = 1.117; ตัวอยา งท่ี 1-37 int x; // y เทา กับ 0 ไมม ีการเกบ็ คาของเศษที่ไดจากการหาร int y; // z เทา กับ 0.5 float z; x = 1; y = x / 2; z = (float)x / 2.0; เมอ่ื มกี ารใชต วั แปรแบบ float ตวั เลขทน่ี าํ มากระทาํ กบั ตวั แปรแบบ float นจ้ี ะตอ งเปน เลขทศนยิ มดว ย จากตัวอยา งคอื เลข 2 เมอ่ื นํามาทํางานกบั ตัวแปร x ทเ่ี ปน แบบ float เลข 2 จึงตอ งเขียนเปน 2.0 1.8.8 double : ตวั แปรประเภทเลขทศนยิ มความละเอียดสองเทา เปน ตวั แปรทศนยิ มความละเอยี ดสองเทา มขี นาด8ไบตคา สงู สดุ ทเี่กบ็ ไดค อื 1.7976931348623157 x 10308 ใน Arduino มหี นว ยความจาํ จาํ กดั จงึ ไมใ ชต วั แปรประเภทน้ี

30     Arduino IDE MicroBOX-Note การกําหนดคา คงทเ่ี ลขจาํ นวนเตม็ เปนเลขฐานตา งๆ ของ Arduino คาคงที่เลขจาํ นวนเตม็ ก็คือตวั เลขทค่ี ุณเขยี นในโปรแกรมของ Arduino โดยตรงเชน 123 โดยปกตแิ ลว ตวั เลขเหลา นจ้ี ะเปน เลขฐานสบิ (decimal) ถา ตอ งการกาํ หนดเปน เลขฐานอน่ื จะตอ งใชเ ครอ่ื งหมายพเิ ศษระบ เุชน ฐาน ตวั อยา ง 10 (decimal) 123 2 (binary) B1111011 8 (octal) 0173 16 (hexadecimal) 0x7B Decimal กค็ อื เลขฐานสบิ ซึ่งใชในชีวิตประจําวัน ตัวอยาง 101 = 101 มาจาก (1* 102) + (0 * 101) + (1 * 100) = 100 + 0 + 1 = 101 Binary เปน เลขฐานสอง ตวั เลขแตละหลกั เปน ไดแ ค 0 หรือ 1 ตัวอยาง B101 = 5 ฐานสิบ มาจาก (1 * 22) + (0 * 21) + (1 * 20) = 4 + 0 + 1 = 5 เลขฐานสองจะใชง านไดไ มเกนิ 8 บติ (ไมเกนิ 1 ไบต) มีคาจาก 0 (B0) ถงึ 255 (B11111111) Octal เปน เลขฐานแปด ตวั เลขแตล ะหลกั มีคาจาก 0 ถึง 7 เทา น้นั ตัวอยาง 0101 = 65 ฐานสบิ มาจาก (1 * 82) + (0 * 81) + (1 * 80) = 64 + 0 +1 = 65 ขอ ควรระวงั ในการกาํ หนดคา คงท่ี อยา เผลอใสเ ลข 0 นาํ หนา มฉิ ะนน้ั ตวั คอมไพเลอรจ ะแปลความหมาย ผดิ ไปวาคา ตวั เลขเปนเลขฐาน 8 Hexadecimal (hex) เปน เลขฐานสิบหก ตวั เลขแตละหลกั มีคาจาก 0 ถงึ 9 และตัวอักษร A คือ 10, B คือ 11 ไปจนถึง F ซ่ึงเทา กับ 15 ตัวอยาง 0x101 = 257 ฐานสบิ มาจาก (1 * 162) + (0 * 161) + (1 * 160) = 256 + 0 + 1 = 257

 Arduino IDE31 1.8.9 string : ตวั แปรประเภทขอ ความ เปนตัวแปรเก็บขอความ ซ่ึงในภาษาซีจะนิยามเปนอะเรยของตัวแปรประเภท char ตัวอยา งท่ี 1-38 ตัวอยา งการประกาศตัวแปรสตริง 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\"; char Str5[8] = \"arduino\"; char Str6[15] = \"arduino\";  Str1 เปน การประกาศตัวแปรสตรงิ โดยไมไดกาํ หนดคา เรมิ่ ตน  Str2 ประกาศตวั แปรสตรงิ พรอ มกาํ หนดคา ใหก บั ขอ ความทลี ะตวั อกั ษร หากไมค รบตามจาํ นวนทปี่ ระกาศ คอมไพเลอรจ ะเพิ่ม null string ใหเ องจนครบ (จากตวั อยา งประกาศไว 8 ตัว แตข อ ความมี 7 ตัวอักษร จึงมกี ารเตมิ null string ใหอ ีก 1 ตัว  Str3 ประกาศตวั แปรสตรงิ พรอ มกําหนดคา ใหก บั ขอความ แลว ปด ทา ยดวยตัวอกั ษรปด น่ันคือ \\0  Str4 ประกาศตวั แปรสตรงิ พรอ มกาํ หนคคา ตวั แปรในเครอ่ื งหมายคาํ พดู จากตวั อยา ง ไมไ ดก าํ หนดขนาด ตวั แปร คอมไพเลอรจ ะกาํ หนดขนาดใหเ องตามจาํ นวนตวั อกั ษร  Str5 ประกาศตวั แปรสตรงิ พรอ มกาํ หนคคา ตวั แปรในเครอ่ื งหมายคาํ พดู และขนาดของตวั แปร จากตวั อยา ง ประกาศไว 8 ตัว  Str6 ประกาศตวั แปรสตรงิ โดยกาํ หนดขนาดเผ่อื ไวส าํ หรบั ขอความอนื่ ท่ียาวมากกวา นี้ 1.8.9.1 การเพิ่มตัวอักษรแจงวาจบขอความ (null termination) ในตวั แปรสตรงิ ของภาษา C กาํ หนดใหต วั อกั ษรสดุ ทา ยเปน ตวั แจง การจบขอ ความ (null string) ซงึ่ กค็ อื ตวั อกั ษร \\0 ในการกาํ หนดขนาดของตวั แปร (คา ในวงเลบ็ เหลยี่ ม) จะตอ งกาํ หนดใหเ ทา กบั จาํ นวนตวั อกั ษร + 1 ดงั ในตวั แปร Str2 และ Str3 ในตวั อยา งท่ี1-38 ทข่ี อ ความ Arduino มตี วั อกั ษร 7 ตวั ในการประกาศตวั แปรตอ งระบเุ ปน [8] ในการประกาศตัวแปรสตริง ตองเผ่ือพ้ืนท่ีสําหรับเก็บตัวอักษรแจงวาจบขอความ มิฉะนั้น คอมไพเลอรจ ะแจง เตือนวา เกิดการผิดพลาด ในตัวอยางท่ี 1-38 ตัวแปร Str1 และ Str6 เกบ็ ขอ ความ ไดส งู สดุ 14 ตัวอักษร 1.8.9.2 เคร่ืองหมายคําพูดขีดเดียวและสองขีด ปกติแลวจะกําหนดคา ตัวแปรสตริงภายในเครอื่ งหมายคําพดู เชน \"Abc\" สําหรบั ตัวแปรตัว อกั ษร (char) จะกําหนดคาภายในเครอื่ งหมายคําพดู ขีดเดียว 'A'

32     Arduino IDE 1.8.10 ตัวแปรอะเรย (array) ตวั แปรอะเรยเ ปน ตวั แปรหลายตวั ทถี่ กู เกบ็ รวมอยใู นตวั แปรชอื่ เดยี วกนั โดยอา งถงึ ตวั แปรแตล ะ ตวั ดว ยหมายเลขดชั นที เี่ ขยี นอยใู นวงเลบ็ สเ่ี หลย่ี ม ตวั แปรอะเรยข อง Arduino จะอา งองิ ตามภาษา C ตวั แปรอะเรยอ าจจะดซู บั ซอ น แตถ า ใชเ พยี งตวั แปรอะเรยอ ยา งตรงไปตรงมาจะงา ยตอ การทาํ ความเขา ใจ ตัวอยางท่ี 1-39 ตัวอยางการประกาศตัวแปรอะเรย int myInts[6]; int myPins[] = {2, 4, 8, 3, 6}; int mySensVals[6] = {2, 4, -8, 3, 2}; char message[6] = “hello”;  ผพู ฒั นาโปรแกรมสามารถประกาศตัวแปรอะเรยไดโ ดยยงั ไมกาํ หนดคา ของตวั แปร myInts  การประกาศตัวแปร myPins เปน การประกาศตัวแปรอะเรยโดยไมร ะบุขนาด เมอ่ื ประกาศตวั แปรแลว ตองกาํ หนดคา ทันที เพอื่ ใหค อมไพเลอรน ับวา ตัวแปรมสี มาชิกกต่ี ัวและกําหนดคา ไดถูกตอ ง จากตัวอยา งมที งั้ สน้ิ 5 ตัว  ในการประกาศตวั แปรอะเรย ผพู ฒั นาโปรแกรมสามารถประกาศและกําหนดขนาดของตวั แปรอะเรยได ในพรอมกันดงั ตวั อยา งการประกาศตัวแปร mySensVals ทปี่ ระกาศทงั้ ขนาดและกําหนดคา  ตวั อยา งสดุ ทา ยเปน การประกาศอะเรยข องตวั แปร message ทเ่ี ปน แบบ char มีตวั อกั ษร 5 ตัวคอื hello แตก ารกาํ หนดขนาดของตวั แปรจะตอ งเผอื่ ทสี่ าํ หรบั เกบ็ ตวั อกั ษรแจง จบขอ ความดว ย จงึ ทาํ ใหค า ดชั นตี อ งกาํ หนดเปน 6 1.8.10.1 การใชงานตัวแปรอะเรย พมิ พช อื่ ตวั แปรพรอ มกบั ระบคุ า ดชั นภี ายในเครอื่ งหมายวงเลบ็ สเ่ี หลยี่ ม คา ดชั นขี องตวั แปรอะเรย เรม่ิ ตน ดว ย 0 ดงั นน้ั คา ของตวั แปร mySensVals มคี า ดงั น้ี mySensVals[0] == 2, mySensVals[1] == 4 การกําหนดคาใหกับตัวแปรอะเรย ทาํ ไดดังนี้ mySensVals[0] = 10; การเรียกคาสมาชกิ ของตัวแปรอะเรย ทาํ ไดดงั น้ี x = mySensVals[4]; 1.8.10.2 อะเรยและคําสั่งวนรอบ for โดยทวั่ ไปจะพบการใชง านตวั แปรอะเรยภ ายในคาํ สงั่ for โดยใชค า ตวั แปรนบั รอบของคาํ สงั่ for เปน คา ดชั นขี องตวั แปรอะเรย ดงั ตวั อยา งตอ ไปน้ี ตัวอยา งที่ 1-40 int i; for (i = 0; i < 5; i = i + 1) { Serial.println(myPins[i]); // แสดงคา สมาชิกของตวั แปรอะเรยท ห่ี นาตาง Serial monitor }

  Arduino IDE33 1.9 ขอบเขตของตวั แปร ตัวแปรในภาษา C ทีใ่ ชใน Arduino จะมีคุณสมบตั ิท่ีเรียกวา “ขอบเขตของตัวแปร” (scope) ซงึ่ แตกตางจากภาษา BASIC ซึง่ ตัวแปรทกุ ตัวมสี ถานะเทาเทียมกนั หมดคอื เปนแบบ global 1.9.1 ตวั แปรโลคอลและโกลบอล ตัวแปรแบบโกลบอล (global variable) เปนตัวแปรท่ีทกุ ฟง กช่ันในโปรแกรมรจู ัก โดยตอง ประกาศตวั แปร นอกฟง กชนั่ สาํ หรบั ตัวแปรแบบโลคอลหรือตวั แปรทอ งถนิ่ เปนตัวแปรทป่ี ระกาศ ตัวแปรอยูภายในเครอื่ งหมายวงเล็บปก กาของฟงกชั่น และรจู ักเฉพาะภายในฟง กชน่ั นัน้ เม่ือโปรแกรมเรม่ิ มขี นาดใหญแ ละซับซอนมากข้ึน การใชตัวแปรโลคอลจะมีประโยชนมาก เนอื่ งจากแนใ จไดว า มแี คฟ ง กช น่ั นน้ั เทา นนั้ ทสี่ ามารถใชง านตวั แปร ชว ยปอ งกนั การเกดิ การผดิ พลาด เมื่อฟง กช่ันทําการแกไขคาตัวแปรทใ่ี ชงานโดยฟง กชน่ั อน่ื ตัวอยางที่ 1-41 int gPWMval; // ทกุ ฟง กช ่ันมองเหน็ ตัวแปรนี้ void setup() // ตัวแปร i จะถูกมองเหน็ และใชงานภายในฟง กช ่ัน loop เทา นั้น {} void loop() { int i; float f; // ตัวแปร f จะถูกมองเหน็ และใชงานภายในฟงกช ่ัน loop เทา น้ัน } 1.9.2 ตวั แปรสแตตกิ (static) เปน คาํ สงวน (keyword) ทใี่ ชต อนประกาศตวั แปรทม่ี ขี อบเขตใชง านแคภ ายในฟง กช น่ั เทา นนั้ โดยตางจากตัวแปรโลคอลตรงที่ตัวแปรแบบโลคอลจะถูกสรางและลบท้ิงทุกครั้งท่ีเรียกใชฟงกชั่น สําหรับตัวแปรสแตติกเมื่อจบการทํางานของฟงกช่ันคาตัวแปรจะยังคงอยู (ไมถูกลบทิ้ง) เปนการ รักษาคาตัวแปรไวระหวางการเรียกใชงานฟงกช่ัน ตัวแปรที่ประกาศเปน static จะถูกสรางและกําหนดคาในคร้ังแรกที่เรียกใชฟงกช่ัน

34   Arduino IDE 1.10 คา คงท่ี (constants) คาคงที่เปน กลุมตัวอักษรหรือขอความที่ไดกําหนดคาไวลวงหนาแลว ตัวคอมไพเลอรของ Arduino จะรูจักกับคาคงท่ีเหลานี้แลว ไมจําเปนตองประกาศหรือกําหนดคาคงที่ 1.10.1 HIGH, LOW : ใชก ําหนดคา ทางตรรกะ ในการอานหรือเขียนคาใหกับขาพอรต ดิจิตอล คาท่เี ปนไดม ี 2 คาคือ HIGH หรือ LOW HIGH เปนการกําหนดคาใหขาดิจิตอลนั้นมีแรงดันเทากับ +5V สว นการอานคา ถาอา น ได +3V หรอื มากกวา ไมโครคอนโทรลเลอรจ ะอา นคาไดเ ปน HIGH คาคงที่ของ HIGH คือ “1” หรอื เทียบเปนตรรกะคือ จรงิ (true) LOW เปนการกําหนดคาใหขาดิจิตอลนั้นมีแรงดันเทากับ 0V สวนการอานคา ถาอานได +2V หรือนอยกวา ไมโครคอนโทรลเลอรจ ะอา นคาไดเ ปน LOW คาคงที่ของ LOW คือ “0” หรอื เทยี บ เปนตรรกะคือ เท็จ (false) 1.10.2 INPUT, OUTPUT : กําหนดทิศทางของขาพอรตดิจติ อล ขาพอรต ดิจติ อลทาํ หนา ทไ่ี ด 2 อยา งคือ เปนอนิ พตุ และเอาตพตุ เมื่อกําหนดเปน INPUT หมายถึง กําหนดใหขาพอรต น้ันๆ เปนขาอนิ พตุ เมื่อกําหนดเปน OUTPUT หมายถงึ กําหนดใหขาพอรต นั้นๆ เปนขาเอาตพตุ 1.11 ตวั กระทําอนื่ ๆ ที่เกย่ี วของกบั ตัวแปร 1.11.1 cast : การเปลี่ยนประเภทตัวแปรชวั่ คราว cast เปนตัวกระทําท่ีใชส่ังใหเปลี่ยนประเภทของตัวแปรไปเปนประเภทอ่ืน และบังคับให คํานวณคาตัวแปรเปนประเภทใหม รูปแบบคําสั่ง (type)variable เมอื่ Type เปน ประเภทของตวั แปรใดๆ (เชน int, float, long) Variable เปนตัวแปรหรอื คา คงทใ่ี ดๆ ตัวอยา งที่ 1-42 int i; float f; f = 4.6; i = (int) f; ในการเปลยี่ นประเภทตวั แปรจาก float เปน int คา ที่ไดจะถูกตดั เศษออก ดงั นนั้ (int)4.6 จงึ กลายเปน 4

  Arduino IDE35 1.11.2 sizeof : แจง ขนาดของตวั แปร ใชแ จง บอกจาํ นวนไบตข องตวั แปรทต่ี อ งการทราบคา ซง่ึ เปน ทงั้ ตวั แปรปกตแิ ละตวั แปรอะเรย รูปแบบคําสั่ง เขยี นไดสองแบบดงั นี้ sizeof(variable) sizeof variable เมอื่ Variable คือตัวแปรปกตหิ รอื ตัวแปรอะเรย (int, float, long) ที่ตองการทราบขนาด ตัวอยา งที่ 1-43 ตัวกระทํา sizeof มีประโยชนอยา งมากในการจดั การกบั ตัวแปรอะเรย (รวมถงึ ตวั แปรสตรงิ ) ตวั อยา งตอ ไปนจี้ ะพมิ พข อ ความออกทางพอรต อนกุ รมครง้ั ละหนงึ่ ตวั อกั ษร 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); } }

36     Arduino IDE 1.12 คาํ สงวนของ Arduino 1.7.10 ทใี่ ชก บั ชดุ กลอ งสมองกล IPST-MicroBOX (SE) คาํ สงวนคอื คา คงท่ี ตวั แปร และฟง กช นั่ ทไ่ี ดก าํ หนดไวเ ปน สว นหนง่ึ ของภาษา C ของ Arduino หา มนาํ คาํ เหลา นไ้ี ปตง้ั ชอ่ื ตวั แปร สามารถแสดงไดด งั น้ี # Constants # Datatypes glcdFillScreen # Other glcdClear HIGH boolean glcdPixel abs LOW byte glcdRect acos INPUT char glcdFillRect += OUTPUT class glcdLine + SERIAL default glcdCircle [] DISPLAY do glcdFillCircle asin PI double glcdArc = HALF_PI int getdist atan TWO_PI long in atan2 LSBFIRST private out & MSBFIRST protected motor &= CHANGE public motor_stop | FALLING return fd |= RISING short bk boolean false signed fd2 byte true static bk2 case null switch tl ceil throw tr char # Literal Constants try sl char unsigned sr class GLCD_RED void servo , GLCD_GREEN sound // GLCD_BLUE # Methods/Fucntions beep ?: GLCD_YELLOW uart_set_baud constrain GLCD_BLACK sw_ok uart_get_baud cos GLCD_WHITE sw_ok_press uart_putc {} GLCD_SKY analog uart_puts — GLCD_MAGENTA knob uart default glcd uart_available delay # Port Constants glcdChar uart_getkey delayMicroseconds glcdString uart1_set_baud / DDRB glcdMode uart1_get_baud /** PINB glcdGetMode uart1_putc . PORTB glcdFlip uart1_puts else DDRC glcdGetFlip uart1 == PINC colorRGB uart1_available exp PORTC setTextColor uart1_getkey false DDRD setTextBackgroundColor uart1_flush float PIND setTextSize float PORTD getTextColor floor getTextBackgroundColor for # Names getTextSize < <= popxt HALF_PI if ++

   Arduino IDE37 != * void serialAvailable int new while printString << null Serial printInteger < () begin printByte <= PII read printHex log return print printOctal && >> write printBinary ! ; println printNewline || Serial available pulseIn ^ Setup digitalWrite shiftOut ^= sin digitalRead compass_read loop sq pinMode compass_set_heading max sqrt analogRead compass_read_heading millis =- analogWrite compass_writeConfig min switch attachInterrupts compass_readConfig - tan detachInterrupts % this beginSerial compass_scan /* true serialWrite encoder TWO_PI serialRead popx2

38     Arduino IDE

  Arduino IDE39         Arduino ในการเขียนโปรแกรมภาษา C/C++ ของ Arduino สง่ิ หนงึ่ ที่มบี ทบาทสาํ คัญมากคือ ตัวแปร (variable) ในแบบตางๆ เน่ืองจากตองใชต ัวแปรในการจดั เกบ็ และประมวลผลขอมลู อยเู สมอ ในบท นจ้ี งึ เปน การนาํ เสนอขอ มลู เพมิ่ เตมิ ทเี่ กย่ี วขอ งกบั การใชง านตวั แปรในลกั ษระตา งๆ เพอ่ื ประโยชนใ น การพัฒนาโปรแกรมตอไป 2.1 การใชง านตัวแปรอะเรย ตวั แปรอะเรยใ ชส าํ หรบั จดั เกบ็ ขอ มลู ชนดิ เดยี วกนั เปน ชดุ ตอ ๆ กนั ซงึ่ ผใู ชง านสามารถกาํ หนด ขนาดของอะเรยได การประกาศตัวแปรอะเรยทําไดตามตัวอยางตอไปนี้ ตัวอยางที่ 2-1 char s[5]; เปน การประกาศตัวแปร s แบบอะเรยของตวั อกั ขระหรอื เรยี กวา สตรงิ (string) ในภาษา C โดยกาํ หนด ขนาดเปน 5 เซล ตัวอยา งท่ี 2-2 char s[5] ={'a','b','c','d','e'}; // ประกาศตวั แปร s แบบอะเรยพรอ มกําหนด คา เรมิ่ ตน 5 คา การเขาถึงสมาชกิ ในแตละเซลของตวั แปรอะเรย ทาํ ไดดงั นี้ char ch0 = s[0]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch0 (คาคือ 'a') char ch1 = s[1]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 1 มาเก็บใน ch1 (คาคือ 'b') char ch2 = s[2]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 2 มาเก็บใน ch2 (คาคือ 'c') char ch3 = s[3]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 3 มาเก็บใน ch3 (คาคือ 'd') char ch4 = s[4]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 4 มาเก็บใน ch4 (คาคือ 'e')

40      Arduino IDE ตัวอยา งที่ 2-3 char s[6] ={'a','b','c','d','e','\\0'}; // ประกาศตวั แปร s แบบอะเรยพ รอ มกําหนดคา เรมิ่ ตน เขาถึงสมาชกิ แตล ะเซลไดด งั น้ี char ch0 = s[0]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch0 (คาคือ 'a') char ch1 = s[1]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 1 มาเก็บใน ch0 (คาคือ 'b') char ch2 = s[2]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 2 มาเก็บใน ch0 (คาคือ 'c') char ch3 = s[3]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 3 มาเก็บใน ch0 (คาคือ 'd') char ch4 = s[4]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 4 มาเก็บใน ch0 (คาคือ 'e') char ch5 = s[5]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 5 มาเก็บใน ch0 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซึง่ มคี า เปน 0) ตัวอยางท่ี 2-4 char s[6] = \"abcde\"; // ประกาศตวั แปร s แบบอะเรยพ รอ มกาํ หนดคา เรม่ิ ตน แบบสายอกั ขระ เขาถึงสมาชกิ แตล ะเซลไดด งั นี้ char ch0 = s[0]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch0 (คาคือ 'a') char ch1 = s[1]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch1 (คาคือ 'b') char ch2 = s[2]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch2 (คาคือ 'c') char ch3 = s[3]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch3 (คาคือ 'd') char ch4 = s[4]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch4 (คาคือ 'e') char ch5 = s[5]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch5 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซึง่ มคี า เปน 0) ตัวอยางที่ 2-5 char s[] = \"abcde\"; เปน การประกาศตวั แปร s แบบอะเรยพ รอ มกาํ หนดคา เรมิ่ ตน แบบสายอกั ขระ โดยไมร ะบจุ าํ นวนเซล ตวั แปล ภาษาหรอื คอมไพเลอรจ ะกาํ หนดใหเ ทา กบั จาํ นวนสตรงิ พรอ มกบั ตวั ปด ทา ยใหอ ตั โนมตั ิ เขา ถงึ สมาชกิ แตล ะ เซลไดดังน้ี char ch0 = s[0]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch0 (คาคือ 'a') char ch1 = s[1]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch1 (คาคือ 'b') char ch2 = s[2]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch2 (คาคือ 'c') char ch3 = s[3]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch3 (คาคือ 'd') char ch4 = s[4]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch4 (คาคือ 'e') char ch5 = s[5]; // โหลดคา จากตวั แปรอะเรย s ตําแหนง 0 มาเก็บใน ch5 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซึ่งมคี า เปน 0)

  Arduino IDE41 ตัวอยางท่ี 2-6 void setup() { Serial.begin(9600); // กาํ หนดอตั ราเรว็ ในการสื่อสารขอมูล 9,600 บิตตอวนิ าที } void loop() { char s[6]= \"abcde\"; // กาํ หนดสตรงิ s เกบ็ อกั ขระ \"abcde\" Serial.println(s); // สง ผลลัพธไ ปแสดงท่ี Serial Monitor delay(1000); // หนวงเวลาในการแสดงผล 1 วนิ าที } 2.2 ตวั แปรพอยนเ ตอรท ่ีใชร ว มกบั สตรงิ ภาษา C ตัวแปรพอยนเตอรทําหนาที่เปนตัวชี้แอดเดรสของขอมูลชนิดเดียวกับขอมูลของตัวแปร พอยนเ ตอรท ท่ี าํ การประกาศโดยจะทาํ หนา ทเี่ ขา ถงึ แอดเดรสของตวั แปรหรอื ขอ มลู ทถ่ี กู ชห้ี รอื อา งองิ ถงึ การประกาศตัวแปรพอยนเตอรหรือตัวชี้สายอักขระทําไดดังนี้ ตัวอยางท่ี 2-7 // ประกาศตวั แปร p แบบพอยนเตอรข องสายตวั อกั ขระในภาษา C char * p; ตัวอยา งที่ 2-8 char * p = \"Hello\"; // ประกาศตวั แปร p ชสี้ ายอกั ขระ \"Hello\" โดย p จะชแี้ อดเดรสอกั ขระตวั แรก ในทนี่ คี้ อื ตาํ แหนง ของ ‘H’ ตัวอยางท่ี 2-9 char * p = ”Hello\"; // ประกาศตวั แปร p ชี้สายอักขระ \"Hello\" char ch0 = *p; // โหลดคา ของขอ มูลจากแอดเดรสท่ี p ชี้อยมู าเก็บท่ี ch0 (คาคือ 'H') char ch1 = *(p+1); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+1 ชอี้ ยมู าเกบ็ ท่ี ch1(คา คอื 'e') char ch2 = *(p+2); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+2 ชอ้ี ยมู าเกบ็ ท่ี ch2 (คา คอื 'l') char ch3 = *(p+3); // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+3 ชอี้ ยมู าเกบ็ ที่ ch3 (คา คอื 'l') char ch4 = *(p+4); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+4 ชอี้ ยมู าเกบ็ ท่ี ch4(คา คอื '0') char ch5 = *(p+5); // โหลดคา ของขอ มูลจากแอดเดรสที่ p+5 ชี้อยมู าเก็บท่ี ch5 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซ่ึงมคี า เปน 0)

42    Arduino IDE ตัวอยางที่ 2-10 char * p = \"Hello\"; // ประกาศตวั แปร p ชี้สายอักขระ \"Hello\" ผพู ฒั นาโปรแกรมสามารถใชพ อยนเ ตอรต วั ชสี้ ายอกั ขระเพอื่ เขา ถงึ ขอ มลู ในรปู แบบเดยี วกบั อะเรยไ ดด งั นี้ char * p = \"Hello\";// ประกาศตวั แปร p ชี้สายอักขระ \"Hello\" char ch0 = p[0]; // โหลดคา ของขอมูลจากแอดเดรสท่ี p ช้ีอยมู าเก็บที่ ch0 (คาคือ 'H') char ch1 = p[1]; // โหลดคา ของขอ มลู จากแอดเดรสที่ p+1 ชอ้ี ยมู าเกบ็ ท่ี ch1(คา คอื 'e') char ch2 = p[2]); // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+2 ชอ้ี ยมู าเกบ็ ท่ี ch2 (คา คอื 'l') char ch3 = p[3]; // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+3 ชอ้ี ยมู าเกบ็ ท่ี ch3 (คา คอื 'l') char ch4 = p[4]; // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+4 ชอี้ ยมู าเกบ็ ที่ ch4(คา คอื '0') char ch5 = p[5]; // โหลดคา ของขอ มูลจากแอดเดรสที่ p+5 ชี้อยมู าเก็บท่ี ch5 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซ่ึงมคี า เปน 0) ตัวอยางท่ี 2-11 ตอไปน้ีคอื ตัวอยา งการใชพอยนเ ตอรช ้ีไปยงั อะเรย เพอื่ เขา ถึงขอ มูลสายอักขระ char str[] = \"ABCDEF\";// ประกาศตวั แปรสตรงิ str เพอ่ื เกบ็ คา สายอกั ขระ \"ABCDEF\" char * p ; // ประกาศตวั แปร p ชี้สายอกั ขระ p = str; // กาํ หนดใหพ อยนเ ตอร p ช้ีไปยงั สตรงิ str char ch0 = *p; // โหลดคา ของขอ มูลจากแอดเดรสที่ p ชี้อยมู าเก็บที่ ch0 (คาคือ 'A') char ch1 = *(p+1); // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+1 ชอ้ี ยมู าเกบ็ ที่ ch1(คา คอื 'B') char ch2 = *(p+2); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+2 ชอ้ี ยมู าเกบ็ ท่ี ch2 (คา คอื 'C') char ch3 = *(p+3); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+3 ชอ้ี ยมู าเกบ็ ท่ี ch3 (คา คอื 'D') char ch4 = *(p+4); // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+4 ชอ้ี ยมู าเกบ็ ที่ ch4(คา คอื 'E') char ch5 = *(p+5); // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+5 ชอี้ ยมู าเกบ็ ที่ ch5 (คา คอื 'F') char ch5 = *(p+6); // โหลดคา ของขอมูลจากแอดเดรสที่ p+6 ชี้อยมู าเก็บที่ ch6 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซง่ึ มคี า เปน 0)

  Arduino IDE43 ตัวอยางที่ 2-12 ตัวอยา งตอ ไปนี้แสดงใหเ หน็ การวนลปู โดยใชพอยนเ ตอรช ี้ไปยงั อะเรย เพอ่ื เขา ถึงขอมูลสายอักขระได Serial.begin(9600); // ประกาศตัวแปรสตรงิ str ใหเ กบ็ คาสายอกั ขระ \"ABCDEF\" ………………………………… // ประกาศตวั แปร p ช้ีสายอักขระ char str[] = \"ABCDEF\"; // กาํ หนดใหพ อยนเ ตอร p ชี้ไปยงั สตรงิ str char * p ; // ตรวจสอบวาขอ มูลทพี่ อยนเ ตอร p ชอี้ ยมู ีคา เปน 0 หรอื ยงั p = str; // (ตัวปดทายสตริง '\\0') while(*p) { Serial.println(*p++); // พมิ พอกั ขระของสตรงิ str ทถี่ ูกช้ีโดย p ออกมาทีละตัวจนครบ ('A' ถึง 'F') // ทกุ ครั้งหลังพมิ พอกั ขระออกมา จะเพ่ิมคาแอดเดรส 1 คา เพอื่ เขา ถึงอักขระท่ีอยถู ัดไป } 2.3 การแปลงออบเจก็ ตส ตรงิ ของ C++ เปน สตรงิ ของภาษา C ทําไดดวยการเรียกผานเมธอด c_str รูปแบบ const char *p c_str() คนื คา แอดเดรสผลลัพธข องการแปลงออบเจ็ตส ตริงของ C++ เปนสตริงแบบภาษา C ตัวอยา งท่ี 2-13 String s = \"Hello\"; const char * p; // ประกาศตวั แปร p เพอื่ รบั ตาํ แหนง การชแ้ี อดเดรสของออบเจก็ ต String p = s.c_str(); // แปลงออบเจ็กตส ตรงิ ใหเ ปน สตรงิ แบบภาษา C char ch0 = *p; // โหลดคา ของขอมูลจากแอดเดรสท่ี p ชี้อยมู าเก็บท่ี ch0 (คาคือ 'H') char ch1 = *(p+1); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+1 ชอี้ ยมู าเกบ็ ที่ ch1(คา คอื 'e') char ch2 = *(p+2); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+2 ชอ้ี ยมู าเกบ็ ที่ ch2 (คา คอื 'l') char ch3 = *(p+3); // โหลดคา ของขอ มลู จากแอดเดรสที่ p+3 ชอ้ี ยมู าเกบ็ ท่ี ch3 (คา คอื 'l') char ch4 = *(p+4); // โหลดคา ของขอ มลู จากแอดเดรสท่ี p+4 ชอ้ี ยมู าเกบ็ ที่ ch4(คา คอื '0') char ch5 = *(p+5); // โหลดคา ของขอมูลจากแอดเดรสที่ p+5 ช้ีอยมู าเก็บที่ ch5 // (คาคือ '\\0' เปน ตัวปด ทา ยสตรงิ ซงึ่ มคี า เปน 0)

44     Arduino IDE 2.4 การแปลงสตรงิ 2.4.1 การแปลงสตรงิ ของภาษา C เปน เลขจาํ นวนเตม็ int ทาํ ไดด วยการเรียกผานฟง กช่นั atoi รูปแบบ int atoi(char * p) พารามเิ ตอร p คอื ตวั ชส้ี ตริงทต่ี อ งการแปลงคา ไปเปน ตวั เลขจาํ นวนเตม็ แบบ int การคืนคา คนื คา เปน ตวั เลขจาํ นวนเตม็ แบบ int ตัวอยา งท่ี 2-14 char s[] = \"1560\"; // ประกาศตวั แปรสตรงิ s เพอื่ กาํ หนดใหเ กบ็ คา ของสายอกั ขระ “1560” int myInt = atoi(s); // แปลงคา สายอกั ขระ s ใหเ ปน เลขจาํ นวนเต็มเกบ็ ไวท ต่ี ัวแปร myInt ผลลพั ธค อื myInt เกบ็ คาตัวเลข 1,560 2.4.2 การแปลงสตรงิ ของภาษา C เปน เลขจาํ นวนเต็ม long ทําไดดวยการเรียกผานฟงกช่ัน atol รูปแบบ long atol(char * p) พารามเิ ตอร p คอื ตวั ชส้ี ตริงทต่ี อ งการแปลงคา ไปเปน ตวั เลขจาํ นวนเตม็ แบบ long การคืนคา คนื คา เปน ตวั เลขจาํ นวนเตม็ แบบ long ตัวอยางท่ี 2-15 char s[] = \"12345678\"; // ประกาศตัวแปรสตรงิ s กาํ หนดใหเ กบ็ คาของสายอักขระ \"12345678\" long myLong = atol(s); // แปลงคา ของสายอักระ s ใหเ ปน เลขจาํ นวนเต็ม long เกบ็ ไวท ตี่ ัวแปร myLong ผลลพั ธค อื myLong เกบ็ คาตัวเลข 12,345,678

  Arduino IDE45 2.4.3 การแปลงสตรงิ ของภาษา C เปน เลขทศนิยม float ทําไดดวยการเรียกผานฟงกช่ัน atof รูปแบบ float atof(char * p) พารามเิ ตอร p คอื ตัวชสี้ ตริงทตี่ อ งการแปลงคาไปเปนตัวเลขทศนยิ มแบบ float การคืนคา คนื คาเปนตัวเลขเลขทศนยิ มแบบ float ตัวอยา งที่ 2-16 char s[] = \"162.864\"; // ประกาศตัวแปรสตรงิ s เกบ็ คาสายอกั ขระ \"162.864\" float myFloat = atof(s); // แปลงสายอกั ระ s เปน เลขทศนยิ ม float เกบ็ ไวท ตี่ วั แปร myFloat ผลลพั ธค อื myFloat เกบ็ คาตัวเลข 162.864 2.4.4 การแปลงสตรงิ ของภาษา C เปน สายอกั ขระ ทําไดดวยการเรียกผานฟงกชั่น sprintf รูปแบบ sprintf ( char * str, const char * format, ... ); พารามเิ ตอร str คอื บฟั เฟอรส ตรงิ ทน่ี าํ มารบั คา ผลลัพธท ไี่ ดจ ากการแปลง format คอื รูปแบบสตริงทกี่ าํ หนดได … คอื ลาํ ดบั ของอะกวิ เมนตท ส่ี อดรับกับ format ตัวอยา งท่ี 2-17 แปลงเลขจาํ นวนเต็มเปน สตริง char s[20]; // ประกาศตวั แปรสตรงิ s สําหรบั เก็บคาจากผลลัพธก ารแปลงสตรงิ sprintf(s,\"Value: %d Volte\",30); // แปลงคา เลขจาํ นวนเตม็ รว มกบั สตรงิ และอกั ขระบงั คบั %d ผลลพั ธค อื s เก็บคาสตรงิ เปน \"Value: 30 Volte\" ตัวอยางท่ี 2-18 แปลงอักขระรวมกับสตริง char s[20]; // ประกาศตวั แปรสตรงิ s สาํ หรบั เก็บคาจากผลลัพธก ารแปลงสตรงิ sprintf(s,\"f(%c) = 3x+1\",'x'); // แปลงอักขระรวมกบั สตรงิ และอกั ขระบงั คบั %c ผลลพั ธค อื s เก็บคาสตริงเปน \"f(x) = 3x+1\"

46     Arduino IDE 2.4.5 การแปลงขอ มลู ตวั เลขเปน สตรงิ ของภาษา C ทาํ ไดด วยการเรยี กผานฟง กช่นั dtostrf รูปแบบ dtostrf (float f_val, byte min, byte digit , char *str); พารามเิ ตอร f_val คอื เลขทศนยิ มทต่ี อ งการแปลง min คอื จาํ นวนหลกั ขอ มลู ขนั้ ตาํ่ ทไ่ี ดจ ากการแปลง digit คอื ความละเอยี ดของหลกั ทศนยิ ม str คอื บฟั เฟอรส ตรงิ ทน่ี าํ มารบั คา ผลลัพธท ไ่ี ดจ ากการแปลง ตัวอยางที่ 2-19 char s[20]; // ประกาศตวั แปรสตรงิ s สาํ หรบั เกบ็ คา จากผลลพั ธก ารแปลงสตรงิ float f = 123456.589468; // ประกาศตวั แปรเลขทศนยิ ม กาํ หนดคา เปน 123,456.589468 dtostrf(f,4,3,s); // แปลงเลขทศนยิ มเปน สตรงิ จากคาของตวั แปร f // จํานวนหลกั ทงั้ หมดทไ่ี ดจ ะมอี ยา งนอย 4 หลกั // การแปลงคา กําหนดใหม ีเลขทศนยิ ม 3 ตําแหนง // ผลลพั ธท ไี่ ดจากการแปลงเกบ็ ไวท ส่ี ตรงิ s ผลลพั ธค อื s เกบ็ คาสตริงเปน \"123456.589\"

  Arduino IDE47 2.5 การใชง านคลาสสตรงิ (string) ใน C++ ของ Arduino เบ้ืองตน 2.5.1 การประะกาศตวั แปรดว ยคลาสสตรงิ การกาํ หนดชนดิ ขอมลู สาํ หรบั ใชจัดการสายอักขระหรอื กลุมขอความใน C++ ของ Arduino สามารถใชคลาส String (สตริง) เปนตัวจดั การสวนนไ้ี ด การประกาศตัวแปรออบเจก็ ตสตริง (String) อยา งเปนทางการทําไดด งั น้ี String str; // กาํ หนดใหต ัวแปร str เปน ออบเจก็ ตส ตรงิ str = String(\"My String\"); // กาํ หนดใหต ัวแปร str เกบ็ ขอความ \"My String\" จากบรรทัดขางตนอาจประกาศเปน str = \"My String\"; หรอื String str = \"My String\"; นอกจากน้ี ยังทําการสรางและกําหนดคาเร่ิมตนใหกับออบเจ็กตสตริงไดหลายแบบ ดงั น้ี String str = String('a'); // กาํ หนดอักขระ 'a' ใหเ ปน คาเรมิ่ ตนของออบเจก็ ต str String str = String(13); // กาํ หนดใหต ัวเลข 13 เมอื่ แปลงไปเปน สตรงิ \"13\" นําไปเปน คาเรม่ิ ตนของออบเจก็ ต str String str = String(120, DEC); // กาํ หนดใหต ัวเลข 120 (ฐานสบิ ) แปลงเปน สตริง \"120\" นําไปเปน คาเรมิ่ ตนของออบเจก็ ต str String str = String(62, HEX); // กาํ หนดใหต ัวเลข 120 (ฐานสบิ หก) แปลงเปน สตรงิ \"3e\" นําไปเปน คาเรมิ่ ตนของออบเจก็ ต str String str = String(255, BIN); // กาํ หนดใหต วั เลข 255 (ฐานสอง) แปลงเปน สตรงิ \"11111111\" นาํ ไปเปน คา เรม่ิ ตน ของออบเจก็ ต str String str = String(7.584, 2); // กาํ หนดใหต ัวเลข 7.584 เมื่อแปลงเปน สตริง ตองแสดงเลขทศนยิ ม 2 ตําแหนง \"7.58\" // และใชเ ปน คา เรม่ิ ตน ของออบเจก็ ต str

48    Arduino IDE 2.5.2 การเชอ่ื มตอ สตรงิ ดว ยโอเปอเรเตอร += ผูพฒั นาโปรแกรมสามารถเชื่อมตอสตรงิ 2 ชดุ เขาดว ยกันดว ยโอเปอเรเตอร += หรอื อาจเรยี ก ผานเมธอด concat รูปแบบ boolean concat(param) ทาํ หนา ทเ่ี ชอื่ มตอ สตรงิ 2 ชดุ เขา ดว ยกนั พารามเิ ตอร param คอื สตรงิ ทนี่ าํ มาเชอื่ มตอ ดว ย การคืนคา - เปน true เมอ่ื ขอความของสตริงทเี่ ปรียบเทยี บตรงกนั - เปน false เมอ่ื ขอความของสตริงทเ่ี ปรียบเทยี บไมต รงกนั ตัวอยา งที่ 2-20 String s = String(\"Hello \");// กําหนดใหตัวแปร s เกบ็ ขอความ \"Hello \" s += \"World\"; // นาํ ขอ ความ \"World\" มาตอ ทา ยสตรงิ ทเ่ี กบ็ อยใู นตวั แปร s ผลลพั ธค อื s เกบ็ ขอความสดุ ทา ยเปน \"Hello World\" ตัวอยางที่ 2-21 String s = String(\"Hello \"); // กาํ หนดใหต ัวแปร s เปน ออบเจก็ ตส ตรงิ เก็บขอความ \"Hello \" s.concat(\"World\"); // นําขอ ความ \"World\" มาตอทา ยสตรงิ ทเี่ กบ็ อยใู นตวั แปร s ผลลพั ธค อื s เกบ็ ขอความสดุ ทา ยเปน \"Hello World\" ตัวอยา งท่ี 2-22 String s = String(\"Value: \"); // กาํ หนดใหต ัวแปร s เปน ออบเจก็ ตส ตรงิ เกบ็ ขอความ \"Value: \" int value = 500; // กาํ หนดใหต ัวแปร value เปน ชนิดเลขจาํ นวนเต็มและกําหนดคา เปน 500 s += value; // นําคา 500 ของตวั แปร value แปลงเปน ขอ ความ \"500\" มาตอทา ยสตรงิ ทเี่ กบ็ อยูใ นตวั แปร s ผลลพั ธค อื s เก็บขอความสุดทายเปน \"Value: 500\"

  Arduino IDE49 ตัวอยา งที่ 2-23 // กาํ หนดใชงานพอรต อะนาลอก A0 #define ANALOG_PIN 0 void setup() { Serial.begin(9600); // กาํ หนดอัตราเรว็ ของการส่อื สารขอมูล 9,600 บิตตอวนิ าที while (!Serial); // รอจนกระทั่งโมดลู สื่อสารอนุกรม 0 พรอ มทํางาน } void loop() { float k = (float)(analogRead(0) * 5.0)/1024.0; // อา นคาสญั ญาณอะนาลอกเพอ่ื แปลงเปน แรงดันไฟฟา ชว ง 0 ถึง +5 V String s1= \"Value: \"; // ประกาศใชงานตัวแปรสตรงิ s1 กาํ หนดคา สตริงเปน \"Value: \" String value = String(k,2); // ประกาศใชง านตัวแปรสตรงิ value กาํ หนดคา สตรงิ เปนคาท่ีไดจากแปลงของตวั แปร value // ซึ่งเปน เลขทศนยิ ม โดยกาํ หนดใหเ ปน เลขทศนยิ ม 2 ตําแหนง s1 +=value; // นาํ สตรงิ มาเชอื่ มตอ กนั เพอื่ เตรยี มแสดงผลตอ ไป Serial.println(s1); // สงผลลพั ธไ ปแสดงทหี่ นาตาง Serial Monitor delay(1000); // หนวงเวลาในการแสดงผล 1 วนิ าที }